Java lambda 表达式、转换和比较器

Question

我正在查看 Java 接口的 Map 源代码，运行进入这个小代码片段：

    /**
     * Returns a comparator that compares {@link Map.Entry} in natural order on value.
     *
     * <p>The returned comparator is serializable and throws {@link
     * NullPointerException} when comparing an entry with null values.
     *
     * @param <K> the type of the map keys
     * @param <V> the {@link Comparable} type of the map values
     * @return a comparator that compares {@link Map.Entry} in natural order on value.
     * @see Comparable
     * @since 1.8
     */
    public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
        return (Comparator<Map.Entry<K, V>> & Serializable)
            (c1, c2) -> c1.getValue().compareTo(c2.getValue());
    }

从方法声明中我了解到这是一个通用方法，return是一个比较器，其类型可以从传递给它的映射条目中推断出来，也可以在方法中显式提供。

真正让我失望的是 return 值。看起来 lambda 表达式

(c1, c2) -> c1.getValue().compareTo(c2.getValue());

被显式转换为 Comparator<Map.Entry<K, V>>。这样对吗？

我还注意到明显的转换包括 & Serializable。我以前从未在强制转换中见过与 class 组合的接口，但它看起来像以下在编译器中有效：

((SubClass & AnInterface) anObject).interfaceMethod();

尽管以下内容不起作用：

public class Foo {
    public static void main(String[] args) {
        Object o = new Foo() {
            public void bar() {
                System.out.println("nope");
            }
        };
        ((Foo & Bar) o).bar();
    }   
}

interface Bar {
    public void bar();
}

那么，两个问题：

向演员表添加接口应该如何工作？这是否只是强制执行接口方法的 return 类型？
你可以将 Lambda 表达式转换为 Comparator 吗？他们还能被塑造成什么？或者 lambda 表达式本质上只是一个 Comparator？有人可以澄清这一切吗？

Answer 1

How does adding an interface to a cast supposed to work?

这具有强制转换的语法，但它实际上定义了您通过类型接口创建的 lambda 的类型。 IE。您不是在创建一个对象的实例，然后将其转换为另一种类型。

Does this just enforce the return type of an interface's method?

这实际上定义了 lambda 将在运行时构建的类型。有一个 LambdaMetaFactory 在运行时获取此类型，如果该类型包含 Serializable.

则生成额外的代码

Can you cast a Lambda expression to a Comparator?

您只能将引用转换为对象已有的类型。在这种情况下，您定义要创建的 lambda 必须是 Comparator。您可以使用任何只有一个抽象方法的类型。

Or is a lambda expression essentially just a Comparator?

可以在不同的上下文和不同的界面中使用（复制+粘贴）相同的 lambda 代码而无需更改。它不一定是 Comparator，正如您将在 JDK.

中的许多其他示例中看到的那样

我觉得有趣的一个是 Stream 上的 count 方法。

Answer 2

根据 Java Language Specification，转换运算符（括号中的任何内容）可以是 ReferenceType 后跟一个或多个 AdditionalBound 项，即一个或多个接口类型。此外，规范还指出，如果操作数的编译时类型可能永远不会根据强制转换规则强制转换为强制转换运算符指定的类型，则为编译时错误.

在你的情况下 Foo 没有实现 Bar，但这个事实在编译时可能并不明显，所以你得到一个 ClassCastException 因为虽然匿名 class 与 Bar 中定义的签名相同，对象未明确实现 Bar。此外，在匿名 classes 中定义的方法是隐藏的，除非在与定义它们时相同的语句中调用，即

new MyClass() {
  void doSomethingAwesome() { /* ... */ }
}.doSomethingAwesome();

有效，但这无效：

MyClass awesome = new MyClass() {
  void doSomethingAwesome() { /* ... */ }
};
// undefined method, does not compile!
awesome.doSomethingAwesome();

Answer 3

虽然 Peter 已经给出了很好的答案，但让我添加更多内容以进一步说明。

lambda 仅在初始化时获取其精确类型。这是基于目标类型。例如：

Comparator<Integer> comp = (Integer c1, Integer c2) -> c1.compareTo(c2);
BiFunction<Integer, Integer, Integer> c = (Integer c1, Integer c2) -> c1.compareTo(c2);
Comparator<Integer> compS = (Comparator<Integer> & Serializable) (Integer c1, Integer c2) -> c1.compareTo(c2);

在所有 3 种情况下，它的 lambda 都相同，但它根据您提供的引用类型获取其类型。因此，您可以在每种情况下将相同的 lambda 设置为 3 种不同的类型。

但请注意，一旦设置了类型（在初始化时），就不能再更改。它在字节码级别被吸收。所以很明显你不能将 c 传递给期望 Comparator 的方法，因为一旦初始化它们就像普通的 java 对象一样。（你可以看看这个 class 玩转并随时生成 lambdas）

所以在以下情况下：

(Comparator<Map.Entry<K, V>> & Serializable)
            (c1, c2) -> c1.getValue().compareTo(c2.getValue());

lambda 已使用其目标类型初始化为 Comparator 和 Serializable。注意 return 类型的方法只是 Comparator，但是因为 Serializable 在初始化时也被写入它，所以它总是可以被序列化，即使这个消息在方法签名中丢失了。

请注意，转换为 lambda 与 ((Foo & Bar) o).bar(); 不同。在 lambda 的情况下，您正在使用其类型作为声明的目标类型来初始化 lambda。但是使用 ((Foo & Bar) o).bar();，您将变量 o 类型转换为 Foo 和 Bar。在前一种情况下，您正在设置类型。在后一种情况下，它已经有一个类型，而您正在尝试将其转换为其他类型。因此在前者中，它抛出 ClassCastException 因为它无法将 o 转换为 Bar

How does adding an interface to a cast supposed to work?

对于对象，就像平常一样。对于 lambda，如上所述。

Does this just enforce the return type of an interface's method?

没有。 Java 没有 Structural Types。所以没有基于方法的特殊类型。它只是试图将 o 转换为 SO1 和 Bar 并且由于后者

而失败

Can you cast a Lambda expression to a Comparator? What else can they be cast as? Or is a lambda expression essentially just a Comparator? Can someone clarify all of this?

如上所述。 lambda 可以初始化为任何 FunctionalInterface based on what all interfaces are eligible for that lambda. In above examples, you obviously cant initialize (c1, c2) -> c1.compareTo(c2) to a Predicate

Java lambda 表达式、转换和比较器

Java lambda expressions, casting, and Comparators

java

lambda

casting

java-8