Difference between "? extends Stream<? extends R>" and "Stream<? extends R>"

Question

What's the difference between

? extends Stream<? extends R>

and

Stream<? extends R>

Is <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper) same as <R> Stream<R> flatMap(Function<? super T, Stream<? extends R>> mapper).

Could you give some examples?

Answer 1

Short answer: ? extends SomeType is very different than SomeType.

Longer answer:

The use of Stream<extends R> as SomeType confuses the example. To answer the question, consider a simpler comparison, for example:

? extends Integer

Integer

The first observation is that ? extends Integer as a type expression can be used only within generic declarations. On the other hand, Integer can be used in many more places.

Here are some code examples to help show the difference:

    // The following do not compile:
    //
    // Syntax error on tokens, delete these tokens ('? extends').
    //
    // private Integer value;
    // public ? extends Integer getValue() {
    //     return value;
    // }
    //
    // Syntax error on tokens, delete these tokens ('? extends').
    //
    // private Integer value;
    // public void setInteger(? extends Integer value) {
    //     this.value = value;
    // }
    //
    // In both cases, the use of bounded quantification ('? extends') is
    // not valid outside of a generic type declaration.

    // Here is a very basic example of the use of generics:
    //
    // Generic 'Wrapped' is quantified on a single type, which
    // is unrestricted:

    public class Wrapped<T> {
        Wrapped() { this.value = null; }
        Wrapped(T value) { this.value = value; }
        private T value;
        public void set(T value) { this.value = value; }
        public T get() { return value; }
    }

    // The following is also valid:
    //
    // 'Wrapped_1' is quantified on a single type, which is restricted
    // to be 'Integer' or a subtype of 'Integer'.

    public class Wrapped_1<T extends Integer> {
        // EMPTY
    }
    
    // This is not valid.  In addition to being non-valid syntacticly,
    // the declaration needs a specific type.  Use of a wildcard does
    // not provide a specific type.
    //
    // Syntax error on token "?", Identifier expected
    //
    // public class Wrapped_2<? extends Integer> {
    // }

    // The following does not compile:
    //
    // Cannot instantiate the type Wrapped<? extends Integer>.
    // Type mismatch: cannot convert from Wrapped<? extends Integer> to Wrapped<Integer>.
    //
    // private Wrapped<Integer> Wrapped0 = new Wrapped<? extends Integer>();

    // These show the difference in effect between the declarations
    // 'Integer' and '? extends Integer'.

    private Wrapped<Integer> wrapped_1 = new Wrapped<Integer>( new Integer(4) );
    private Wrapped<? extends Integer> wrapped_2 = wrapped_1;
    
    {
        // This compiles:
        wrapped_1.set( new Integer(5) );

        // This does not compile:
        //
        // The method set(capture#1-of ? extends Integer)
        // in the type Wrapped<capture#1-of ? extends Integer>
        // is not applicable for the arguments (Integer)
        //
        // wrapped2.set( new Integer(6) );
    }

Answer 2

let say R = Number

Stream<? extends R> can be Stream<Integer> Stream<Long>

But ? extends Stream<? extends R> says which implements Stream<Number> or Stream<Integer> and so on.... class XXXX implements Stream<Integer>{} ... XXXX overrides all the Stream abstract methods