java 8选项列表收集到列表编译错误

我很难理解两者之间的区别

Stream<Optional<Integer>> optionalStream = Stream.of(
                Optional.of(1),
                Optional.empty(),
                Optional.of(5));

List<Optional<Integer>> optionalList = optionalStream.collect(Collectors.toList());

Stream optionalStream=Stream.of(
（1）中的可选项，
可选。空（），
第（5）款的任择规定；
List optionalList=optionalStream.collect（Collectors.toList（））；

这很好用，而且：

List<Optional<Integer>> optionalList1 = Stream.of(
                Optional.of(1),
                Optional.empty(),
                Optional.of(5)).collect(Collectors.toList());

List optionalList1=Stream.of(
（1）中的可选项，
可选。空（），
可选.of（5））.collect（collector.toList（））；

我在哪里收到错误

Error:(138, 40) java: incompatible types: inference variable T has incompatible bounds
    equality constraints: java.util.Optional<java.lang.Integer>
    lower bounds: java.util.Optional<? extends java.lang.Object>

Error:（138,40）java:不兼容类型：推理变量T的边界不兼容
等式约束：java.util.Optional
下限：java.util.Optional
Stream.of（…）
或
Optional.empty（）
是通用方法。如果不提供类型参数，则将对其进行推断。对于
Optional.empty（）
您将得到
Optional
因此
Stream.of（Optional.of（1）、Optional.empty（）、Optional.of（5））
将导致
Stream我已经减少了一些示例，并尝试使用
-xdwerbosesolution=all
编译以输出有关类型推断的信息：

final class One {
  void one() {
    Stream<Optional<Integer>> optionalStream = Stream.of(Optional.empty());
    List<Optional<Integer>> optionalList = optionalStream.collect(Collectors.toList());
  }
}

final class Two {
  void two() {
    List<Optional<Integer>> optionalList1 =
        Stream.of(Optional.empty()).collect(Collectors.toList());
  }
}

（首先提到的是“解析方法
collect
）

没有约束它的
目标类型
；实例化的签名显示它是一个
流

如果查看
One
的相应输出：

...
One.java:8: Note: Deferred instantiation of method <T>of(T)
    Stream<Optional<Integer>> optionalStream = Stream.of(Optional.empty());
                                                        ^
  instantiated signature: (Optional<Integer>)Stream<Optional<Integer>>
  target-type: Stream<Optional<Integer>>
  where T is a type-variable:
    T extends Object declared in method <T>of(T)
...

如果您添加一个提示（例如，
Stream.of（/*etc*/
），第二个是否有效？是的！为什么会发生这种情况？好吧，您只是给类型推断算法更多的约束。实际上，更容易添加的是
Optional.empty（）
。感觉不应该这样做，但在当前的实现中就是这样。”对于
可选的.empty（）
您将得到
可选的
“但在第一种情况下，你不能这样做，否则它就不起作用。这个答案修复了症状，但没有解释差异。OP代码中的第一种和第二种情况都包含
可选的.empty（）
。如果，正如你所说，这是
可选的类型，那么第一种情况也不会起作用。（顺便说一句，我不是下一个选民）。
...
One.java:8: Note: Deferred instantiation of method <T>of(T)
    Stream<Optional<Integer>> optionalStream = Stream.of(Optional.empty());
                                                        ^
  instantiated signature: (Optional<Integer>)Stream<Optional<Integer>>
  target-type: Stream<Optional<Integer>>
  where T is a type-variable:
    T extends Object declared in method <T>of(T)
...

final class Three {
  void three() {
    List<Optional<Integer>> optionalList1 =
        Stream.of(Optional.<Integer>empty()).collect(Collectors.toList());
  }
}

...
Three.java:9: Note: resolving method of in type Stream to candidate 1
        Stream.of(Optional.<Integer>empty()).collect(Collectors.toList());
              ^
  phase: BASIC
  with actuals: Optional<Integer>
  with type-args: no arguments
  candidates:
      #0 not applicable method found: <T#1>of(T#1...)
        (cannot infer type-variable(s) T#1
          (argument mismatch; Optional<Integer> cannot be converted to T#1[]))
      #1 applicable method found: <T#2>of(T#2)
        (partially instantiated to: (Optional<Integer>)Stream<Optional<Integer>>)
  where T#1,T#2 are type-variables:
    T#1 extends Object declared in method <T#1>of(T#1...)
    T#2 extends Object declared in method <T#2>of(T#2)
Three.java:9: Note: Deferred instantiation of method <T>of(T)
        Stream.of(Optional.<Integer>empty()).collect(Collectors.toList());
                 ^
  instantiated signature: (Optional<Integer>)Stream<Optional<Integer>>
  target-type: <none>
  where T is a type-variable:
    T extends Object declared in method <T>of(T)
...