Why is "? extends" required here in the type declaration

user_430665 0
Viewed 76

I noticed that this Java 17 code snippet doesn't compile.

class Foo<T> {
    public Optional<T> getSomeOptional() {
        return Optional.empty();
    }
}

class Bar {
    List<Foo<?>> fooList = new ArrayList<>();
    void bar() {
        List<Optional<?>> list = fooList.stream().map(Foo::getSomeOptional).toList();
    }
}

but changing class Bar to this works.

class Bar {
    List<Foo<?>> fooList = new ArrayList<>();
    void bar() {
        List<? extends Optional<?>> list = fooList.stream().map(Foo::getSomeOptional).toList();
    }
}

Why is ? extends required here in the declaration?

java-stream generics java
3 Answers

Compilers don't always infer types of complex expressions correctly. In this case, it may help to break them into parts. E.g. in your case, this works:

void bar() {
    Stream<Optional<?>> stream = fooList.stream().map(Foo::getSomeOptional);
    List<Optional<?>> list = stream.toList();
}
user_171417160

The type guessed by type inference (i.e. when you call a generic method without a type witness) is not always what you want. I think here what happened is that Foo::getSomeOptional takes a Foo<T> and returns an Optional<T>, so the compiler tries to "capture" the wildcard from Foo<?> into an unnamed type variable, so it thinks the result is Optional<some capture>. So you get List<Optional<some capture>>, rather than List<Optional<?>>. Although Optional<some capture> is a subtype of Optional<?>, List<Optional<some capture>> is not a subtype of List<Optional<?>>, since generics are invariant.

If you add the following type witness to tell it that you want Optional<?> (with the plain wildcard) as the result type, it should compile:

List<Optional<?>> list =
    fooList.stream().<Optional<?>>map(Foo::getSomeOptional).toList();
user_869890

This thing you have used is called wildcards.

https://www.geeksforgeeks.org/wildcards-in-java/

Because of Java Type Erasure in the Compile Time, if we don't use a type for our generics then it is considered from the object type, so we use "?" sign or wildcards, by this we basically say that if we pass something in the declaration instead of ?, the compiler should bound the generic to that and don't make it object type.

Note: if you don't bound with anything no matter what type you use, because of java Erasure it's type will become it's super class(the top one).

user_182379770
Related