有办法比较lambdas吗？

Question

假设我有一个使用lambda表达式（闭包）定义的对象列表。有没有办法检查它们以便进行比较？

我最感兴趣的代码是

    List<Strategy> strategies = getStrategies();
    Strategy a = (Strategy) this::a;
    if (strategies.contains(a)) { // ...

完整的代码是

import java.util.Arrays;
import java.util.List;

public class ClosureEqualsMain {
    interface Strategy {
        void invoke(/*args*/);
        default boolean equals(Object o) { // doesn't compile
            return Closures.equals(this, o);
        }
    }

    public void a() { }
    public void b() { }
    public void c() { }

    public List<Strategy> getStrategies() {
        return Arrays.asList(this::a, this::b, this::c);
    }

    private void testStrategies() {
        List<Strategy> strategies = getStrategies();
        System.out.println(strategies);
        Strategy a = (Strategy) this::a;
        // prints false
        System.out.println("strategies.contains(this::a) is " + strategies.contains(a));
    }

    public static void main(String... ignored) {
        new ClosureEqualsMain().testStrategies();
    }

    enum Closures {;
        public static <Closure> boolean equals(Closure c1, Closure c2) {
            // This doesn't compare the contents 
            // like others immutables e.g. String
            return c1.equals(c2);
        }

        public static <Closure> int hashCode(Closure c) {
            return // a hashCode which can detect duplicates for a Set<Strategy>
        }

        public static <Closure> String asString(Closure c) {
            return // something better than Object.toString();
        }
    }    

    public String toString() {
        return "my-ClosureEqualsMain";
    }
}

看来唯一的解决方案是将每个lambda定义为一个字段，并仅使用这些字段。如果要打印调用的方法，最好使用method。使用lambda表达式有更好的方法吗？

此外，是否可以打印一个lambda并获得一些人类可读的内容？如果您打印this:：a而不是

ClosureEqualsMain$$Lambda$1/821270929@3f99bd52

得到类似于

ClosureEqualsMain.a()

甚至可以使用这个。toString和方法。

my-ClosureEqualsMain.a();

Answer 1

我不认为有可能从闭包中得到这些信息。闭包不提供状态。

但是你可以使用Java反射，如果你想检查和比较的方法。当然，这不是一个非常漂亮的解决方案，因为性能和异常，这是要抓住的。但是这样你就可以得到那些元信息。

Answer 2

为了比较labmdas，我通常让接口扩展Serializable，然后比较序列化的字节。不是很好，但在大多数情况下都有效。

Answer 3

这个问题可以根据规范或实现来解释。显然，实现可能会发生变化，但当这种情况发生时，您可能愿意重写代码，所以我将同时回答这两个问题。

这也取决于你想做什么。您是在寻求优化，还是在寻求两个实例是（或不是）相同功能的铁一般保证？（如果是后者，你会发现自己与计算物理不一致，因为即使是像询问两个函数是否计算同一事物这样简单的问题也是不可判定的。）

从规范的角度来看，语言规范只promise计算（而不是调用）lambda表达式的结果是实现目标函数接口的类的实例。它并没有promise结果的身份或混叠程度。这是出于设计，为实现提供最大的灵活性以提供更好的性能（这就是lambdas比内部类更快的原因；我们不受内部类的“必须创建唯一实例”约束的约束）

所以基本上，规范不会给你太多，除了两个引用相等的lambda（==）将计算相同的函数。

从实现的角度来看，您可以得出更多结论。在实现lambdas的合成类和程序中的捕获站点之间存在（目前可能会改变）1:1的关系。所以两段独立的代码捕获“x-

如果您的lambda是可序列化的，那么它们将更容易放弃其状态，以换取牺牲一些性能和安全性（没有免费的午餐）

调整相等的定义可能是实用的一个领域是方法引用，因为这将使它们能够被用作侦听器并被正确地取消注册。这一点正在考虑之中。

我认为您要了解的是：如果两个lambda被转换为相同的函数接口，由相同的行为函数表示，并且具有相同的捕获参数，那么它们是相同的

不幸的是，这既很难做到（对于不可序列化的lambda，您无法获得它的所有组件），也不够（因为两个单独编译的文件可能会将相同的lambda转换为相同的函数接口类型，您无法判断）

EG讨论了是否要公开足够的信息来做出这些判断，以及lambdas是否应该实现更具选择性的equals/hashCode或更具描述性的toString。我们的结论是，我们不愿意支付任何性能成本来向调用方提供这些信息（糟糕的折衷，99.99%的用户因受益0.01%而受到惩罚）。

关于toString的最终结论尚未达成，但仍有待将来再次讨论。但是,双方在这个问题上都有一些很好的论据,；这不是扣篮。