Java 8/11中成员引用存入变量后无法相等比较的问题

一、编译失败原因：方法引用的上下文依赖 #

你遇到的assertEquals(choice1a, MethodReferenceInterface::one)编译失败，核心原因是Java方法引用的类型推断需要明确的目标上下文：

• 方法引用本身不是具体对象，是一种语法糖，编译器需要根据目标上下文（即明确的函数式接口类型）将其转换为对应实例。
• assertEquals(Object, Object)的参数是Object，编译器无法推断MethodReferenceInterface::one应该转换成什么函数式接口类型，因此报错“目标类型必须是函数式接口”。

解决编译问题的方法是显式指定类型转换：

assertEquals(choice1a, (Function<String, Integer>) MethodReferenceInterface::one);

二、方法引用相等性失效的原因 #

即使编译通过，choice1a（直接赋值的方法引用）和choice1b（从枚举中获取的方法引用）依然不相等，这是Java语言规范明确规定的行为：

对于方法引用和Lambda表达式，Java不保证每次转换都会生成同一个实例。即使是同一个方法的引用，每次赋值、传递参数时，编译器都可能生成全新的函数式接口实例。

因此：

• ==比较对象引用，自然不相等；
• equals()默认继承自Object，同样比较引用，结果不相等；
• hashCode()每个实例的哈希值不同，比较也失效。

三、实现需求的可行方案 #

你的核心需求是“判断实例成员是否等于特定静态方法引用”，直接比较函数式接口实例不可行，推荐以下方案：

方案1：通过反射绑定方法元数据 #

利用Java反射的Method对象（同一个静态方法的Method实例是全局单例），给枚举增加Method字段标识对应方法，通过比较Method对象判断是否指向同一方法：

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;

import java.lang.reflect.Method;
import java.util.function.Function;

import org.junit.jupiter.api.Test;

enum MethodReferenceEnum {
    One("One", MethodReferenceInterface::one, getMethod("one")),
    Two("Two", MethodReferenceInterface::two, getMethod("two"));

    public String name;
    public Function<String, Integer> method;
    public Method methodHandle;

    private MethodReferenceEnum(String aName, Function<String, Integer> aMethod, Method methodHandle) {
        name = aName;
        method = aMethod;
        this.methodHandle = methodHandle;
    }

    private static Method getMethod(String methodName) {
        try {
            return MethodReferenceInterface.class.getMethod(methodName, String.class);
        } catch (NoSuchMethodException | SecurityException e) {
            throw new RuntimeException(e);
        }
    }
}

interface MethodReferenceInterface {
    public static Integer one(String aString) {
        return 1;
    }
    public static Integer two(String aString) {
        return 2;
    }
}

class MethodRererencesTest {

    @Test
    void LocalUseTest() {
        Function<String, Integer> choice1a = MethodReferenceInterface::one;
        Method choice1aMethod = getMethod("one");
        // 通过Method对象判断是否指向同一方法
        assertEquals(MethodReferenceEnum.One.methodHandle, choice1aMethod);
    }

    private static Method getMethod(String methodName) {
        try {
            return MethodReferenceInterface.class.getMethod(methodName, String.class);
        } catch (NoSuchMethodException | SecurityException e) {
            throw new RuntimeException(e);
        }
    }
}

方案2：直接使用枚举实例判断 #

如果业务逻辑围绕枚举展开，可以跳过函数式接口实例的比较，直接判断枚举本身：

public void executeLogic(MethodReferenceEnum targetEnum) {
    if (targetEnum == MethodReferenceEnum.One) {
        // 执行对应MethodReferenceInterface::one的逻辑
        targetEnum.method.apply("test");
    }
}

这种方式更直接，避免了反射复杂度，是最推荐的方案。

方案3：自定义带标识的函数式接口 #

如果必须使用函数式接口实例比较，可以自定义包含方法标识的接口，重写equals和hashCode：

import java.lang.reflect.Method;
import java.util.function.Function;

interface IdentifiableFunction<T, R> extends Function<T, R> {
    Method getMethod();

    @Override
    default boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        IdentifiableFunction<?, ?> that = (IdentifiableFunction<?, ?>) o;
        return getMethod().equals(that.getMethod());
    }

    @Override
    default int hashCode() {
        return getMethod().hashCode();
    }

    static <T, R> IdentifiableFunction<T, R> of(Method method, Function<T, R> function) {
        return new IdentifiableFunction<T, R>() {
            @Override
            public Method getMethod() {
                return method;
            }

            @Override
            public R apply(T t) {
                return function.apply(t);
            }
        };
    }
}

枚举中使用该接口：

enum MethodReferenceEnum {
    One("One", IdentifiableFunction.of(getMethod("one"), MethodReferenceInterface::one)),
    Two("Two", IdentifiableFunction.of(getMethod("two"), MethodReferenceInterface::two));

    public String name;
    public IdentifiableFunction<String, Integer> method;

    private MethodReferenceEnum(String aName, IdentifiableFunction<String, Integer> aMethod) {
        name = aName;
        method = aMethod;
    }

    private static Method getMethod(String methodName) {
        try {
            return MethodReferenceInterface.class.getMethod(methodName, String.class);
        } catch (NoSuchMethodException | SecurityException e) {
            throw new RuntimeException(e);
        }
    }
}

此时比较函数式接口实例会返回true：

IdentifiableFunction<String, Integer> choice1a = IdentifiableFunction.of(getMethod("one"), MethodReferenceInterface::one);
assertEquals(choice1a, MethodReferenceEnum.One.method); // 比较成功

内容的提问来源于stack exchange，提问作者Jay Turner