Java 8方法引用到lambda[复制]

Question

我有一段代码，试图将方法引用（“String：：length”）转换为等效的lambda表达式。

 Stream<String> s = Stream.of("hello", "your name", "welcome", "z");

 List<String> list = s.sorted((a, b) -> Comparator.comparingInt(String::length).compare(a, b)).collect(toList());

 // List<String> list = s.sorted((a, b) -> Comparator.comparingInt( p -> {return ((String)p).length();}).compare(a, b)).collect(toList());

注释行中概述了它的唯一工作方式。我需要把论点转换为“p”。

似乎在编译时，如果我使用lambda表达式并且需要显式强制转换，它会将参数“p”的类型指定为对象。见下文：

<Object> Comparator<Object> java.util.Comparator.comparingInt(ToIntFunction<? super Object> keyExtractor)

当我使用String::长度方法引用时，那么在编译时，隐式参数被正确理解为String实例。在这种情况下有什么特别的？见下文。

<String> Comparator<String> java.util.Comparator.comparingInt(ToIntFunction<? super String> keyExtractor)

Answer 1

字符串：：长度的完整lambda为：

(String p) -> p.length()

也可以使用块编写，但更常见的是使用上面更简单的表达式：

(String p) -> { return p.length(); }

如果编译器可以推断类型，则可以忽略它：

p -> p.length()

但您使用的是：

Comparator.comparingInt(p -> p.length())

这就是编译器在需要推断p的类型时看到的全部内容。那么，什么是p？不知道，编译器说。因此，必须明确指定类型：

// Explicit type in parameter list
Comparator.comparingInt((String p) -> p.length())

// Explicit type on generic type parameter
Comparator.<String>comparingInt(p -> p.length())

// You can do both, but why would you?
Comparator.<String>comparingInt((String s) -> s.length())

// Explicit type of referenced method
Comparator.comparingInt(String::length)

请注意，没有任何代码使用强制转换。与您使用强制转换编写的代码不同，上述都是类型安全的。不要使用强制转换！

以上所有4个调用都返回一个比较器

当你这样投的时候：

Comparator.comparingInt(p -> ((String) p).length())

它返回一个比较器

Answer 2

编辑为什么不推断p的类型。

p的类型不会自动推断为String，原因与以下示例中未推断的原因非常相同：

String a = "a";
String b = "b";
Comparator.comparingInt(p -> p.length).compare(a, b);

在这里，它失败了，因为Object没有方法长度。要了解原因，请考虑此表达式的抽象语法树（非常粗略的近似）：

                                                                  Apply
                                                                 /     \
                                                                /       \
                                                               /         \
                                                              /           \
                                             _______________ /             \__
                                            /                                 \
                                           /                                   \
                                          /                                     \
                                  MemberSelection                             ArgumentList(2)
                                  /             \______                       /             \
                                 /                     \                     /               \
                           Apply                      compare              a: String     b: String
                     _____/     \______
                    /                  \
                   /                    \
          MemberSelection             Lambda
          /          |                 |    \
         /           |                 |     \
Comparator     comparingInt       Variable    MemberSelection
                                       |          /      \
                                       p         p       length

如您所见，有关字符串的类型信息完全位于AST的右侧，而变量binder和整个闭包位于AST的左侧分支上。

碰巧的是，类型推理算法总是以自顶向下的方式在本地工作。一旦它下降到左子树中并且无法推断p的类型，它将不会返回树并在右子树中搜索其他提示。这太复杂了，无法实现，类型检查器越是远离有问题的活页夹，关于失败类型推断的错误消息就越不清楚。类型推断算法不会对整个程序进行全局类型检查。

您不需要代码（a、b）-

List<String> list = s.
  sorted(Comparator.comparingInt(String::length)).
  collect(toList());

做你可能想要的。

Answer 3

与其使用匿名lambda来实现功能性比较器接口，不如使用一个直接的比较器：

List<String> list = 
    s.sorted(Comparator.comparingInt(String::length)).collect(toList());