“？延伸Stream <？延伸R>”和“ Stream <？延伸R>”之间的区别

如何解决“？延伸Stream <？延伸R>”和“ Stream <？延伸R>”之间的区别

两者之间有什么区别

？扩展Stream

和

流

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

您能举一些例子吗？

解决方法

简短的回答：? 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) );
    }