java - "? extends Stream " 和 "Stream "的区别

Question

有什么区别

? 扩展流<? 扩展 R>

和

流<? 扩展 R>

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

你能举一些例子吗？

标签： javagenericswildcardflatmap

Answer 1

简短的回答：? extends SomeType与SomeType.

更长的答案：

Stream<extends R>as的使用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) );
    }