为什么Java泛型类型推断会在链式方法调用中中断？

Question

看看下面例子中泛型类型的类型推断，我说不出为什么methodAutoTypeInference工作得很好，但是methodnotcompileable（几乎相同）无法编译，为了管理它，编译器需要额外的技巧，比如methodWorkaroundTypeHint或methodWorkaroundTypeCast。

导致编译器不确定表达式类型和方法结果类型是否兼容的问题是什么？

Stream<CharSequence> methodAutoTypeInference() {
  return Stream.of("a");
}

Stream<CharSequence> methodNotCompilable() {
  return Stream.of("a").distinct(); 
  //    incompatible types:  java.util.stream.Stream<java.lang.String>
  // cannot be converted to  java.util.stream.Stream<java.lang.CharSequence>
}

Stream<CharSequence> methodWorkaroundTypeHint() {
  return Stream.<CharSequence>of("a").distinct();
}

Stream<CharSequence> methodWorkaroundTypeCast() {
  return Stream.of((CharSequence) "a").distinct();
}

Answer 1

您会发现这种行为相当多。尤其是当将比较器链接为编译器时，根本无法推断链中的适当类型。下面是您的解决方案。

Stream<CharSequence> methodWorkaroundTypeHint() {
        return Stream.<CharSequence>of("a").distinct();
}

被称为类型见证，是处理这些问题的典型解决方案。查看此答案以了解更多详细信息。

Answer 2

这是编译器的功能。当你写流时。属于（“a”）With return语句和method of（）编译器的泛型类型从方法参数“a”（Stream）获取类型

当您编写返回流时。属于（“a”） 编译器从返回类型（流）获取类型

换句话说，您不为（）的方法设置泛型类型，当您没有另一个流的方法时，编译器从方法的返回类型获取泛型类型，如果您有其他流的方法，编译器从变量的类型获取类型。

Answer 3

JDK Developers自己给出的答案也涵盖了同样的领域。请注意，斯图尔特·马克斯说：“编译器可能会得到增强，以便在未来的版本中涵盖这种情况”。尽管这种情况与lambdas有关，但这与您的情况没有太大不同。这只是编译器（目前）的工作方式。我们“被卡住了”。

您可以在编译器如何看待返回Stream.of（"a"）的分辨率下进行查找。

javac --debug=verboseResolution=all

它在一个未记录的标志中。如果你用这个标志编译，你会看到一些大的输出：

  with actuals: no arguments
  with type-args: no arguments
  candidates:
      #0 applicable method found: Object()
DeleteMe.java:60: Note: resolving method of in type Stream to candidate 1
        return Stream.of("a").distinct();
                     ^
  phase: BASIC
  with actuals: String
  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; String cannot be converted to T#1[]))
      #1 applicable method found: <T#2>of(T#2)
        (partially instantiated to: (String)Stream<String>)
  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)
DeleteMe.java:60: Note: Deferred instantiation of method <T>of(T)
        return Stream.of("a").distinct();
                        ^
  instantiated signature: (String)Stream<String>
  target-type: <none>
  where T is a type-variable:
    T extends Object declared in method <T>of(T)
DeleteMe.java:60: Note: resolving method distinct in type Stream to candidate 0
        return Stream.of("a").distinct();
                             ^
  phase: BASIC
  with actuals: no arguments
  with type-args: no arguments
  candidates:
      #0 applicable method found: distinct()
  where T is a type-variable:
    T extends Object declared in interface Stream
DeleteMe.java:60: error: incompatible types: Stream<String> cannot be converted to Stream<CharSequence>
        return Stream.of("a").distinct();
                                      ^
1 error

我猜最重要的部分是：（部分实例化为：（String）Stream

您可以看到，T类型的解析是在方法调用的基础上完成的；而不是整个通话链。如果会的话，顺便说一句，这将使编译器的工作变得非常复杂。对于这样一个简单的链，事情可能看起来很琐碎，但当有很多的时候，事情变得越来越棘手和复杂。尤其是，当你发现不可表示的类型时，这将使问题更加复杂。