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”。

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

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

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

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

Answer 1

不要使用匿名 lambda 来实现功能性 Comparator 接口，只需使用直接比较器：

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

Answer 2

编辑关于为什么p的类型没有被推断出来。

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

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

在这里，它失败并显示Object 没有方法length 的消息。要理解为什么，考虑一下这个表达式的抽象语法树（非常粗略的近似）：

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

如您所见，String 的类型信息完全位于 AST 的右侧，而变量 binder p 和整个闭包位于 AST 的左侧分支。

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

---

您根本不需要(a, b) -> ... 部分，Comparator.compare(...) 已经生成了一个比较器：

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

做你可能想做的事。

Answer 3

String::length 的完整 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<String>。该比较器可用于例如对List<String> 进行排序，但如果您尝试对任何其他类型的列表进行排序，则会出现编译错误。

当你这样投射时：

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

它返回一个Comparator<Object>，这意味着您可以在尝试对任何类型的列表进行排序时给出该比较器，例如List<Integer>。它将编译，但在运行时失败。强制转换的使用使得代码不是类型安全的。正如我所说，不要那样做。