"? extends Stream<? extends R>" 和 "Stream<? extends R>" 的区别

Question

有什么区别

？扩展流

和

流

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 是否与<R> Stream<R> flatMap(Function<? super T, Stream<? extends R>> mapper) 相同。

你能举几个例子吗？

Answer 1

简答：? extends SomeType 与 SomeType 非常不同。

更长的答案：

将Stream<extends R> 用作SomeType 会使示例混淆。要回答这个问题，请考虑一个更简单的比较，例如：

? extends Integer

Integer

第一个观察结果是? extends Integer 作为类型表达式只能在泛型声明中使用。另一方面，Integer 可以用在更多地方。

这里有一些代码示例来帮助展示差异：

    // 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) );
    }