Java MethodHandles 是否可以被视为与一等函数相同？

Question

Java Method 类和 Java 7 MethodHandle 类均引用与方法关联的对象，但它们仍然很少使用，并且当需要将一个函数传递给另一个函数时，最好使用实现包含一个方法的接口的匿名类。

（注意：MethodHandles 应该比旧的方法更快。）

为什么这些构造没有更频繁地用于将函数传递给函数？是因为它们仍然冗长吗？

代码示例：

public final class HigherOrder {

public static final List<?> map(final List<?> list, final MethodHandle mh) throws Throwable {
    if (list == null) return null;
    List<Object> ret = new ArrayList<>(list.size());
    for (Object element : list) {
        ret.add(mh.invoke(element));
    }
    return ret;
}

public static final Object reduce(final List<?> list, final MethodHandle mh) throws Throwable {
    if (list == null) return null;
    Object tmp = list.get(0);
    for (int i = 1; i < list.size(); i++) {
        tmp = mh.invoke(tmp, list.get(i));
    }
    return tmp;
}

public static final Integer doubleNumber(final Integer number) {
    return number * 2;
}

public static final Integer sum(final Integer number1, final Integer number2) {
    return number1 + number2;
}

public static void main(String[] args) throws Throwable {
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandle doubleNumber = lookup.unreflect(HigherOrder.class.getMethod("doubleNumber", Integer.class));
    MethodHandle sum = lookup.findStatic(HigherOrder.class, "sum", MethodType.methodType(Integer.class, Integer.class, Integer.class));

    List<?> list = Arrays.asList(1, 2, 3, 4, 5);
    System.out.println(list);
    list = map(list, doubleNumber);
    System.out.println(list);
    System.out.println(reduce(list, sum));
}
}

UPDATE

在进行了一些基准测试之后，我注意到 MethodHandle 比 Reflection 的方法更快，但仍然远不及常规方法调用快。也许对于方法调用，JVM 可以应用一些句柄无法实现的优化。

Answer 1

仅在确实需要时才使用反射。
正如您所看到的，invoke throws Throwable 这意味着您没有得到真正好的异常处理。
其他编译时检查也将被丢弃。

Answer 2

Method 类有其一席之地需要使用反射，这比常规方法调用慢得多。

MethodHandler 是 JSR 292。它针对为 JVM 实现动态语言的人员。您可以在此处阅读有关它的更多信息。它也不意味着取代常规方法调用。

Answer 3

MethodHandles 使用反射，因此速度很慢并且不易重构。此外，Java 将在版本 8 中获得 lambda，这将解决 Java 中的一流函数的问题，因此我认为库编写者更喜欢等待 Java 8，而不是使用某种解决方法。

Answer 4

除了任何性能参数之外，传递Methods或MethodHandles:

• 会失去任何编译时安全性：
  • 参数数量；
  • 参数类型；
  • 方法本身是否存在（您使用字符串名称来查找它）。
• 丢失任何已声明的已检查异常；
• 使自动化重构变得更加困难。

此外，正如您的代码所示，使用Methods或MethodHandles并不会特别减少声明近似第一类函数的对象所需的代码量：

// you could even use the Function types from Guava...
interface Func<In, Out> {
    Out apply(In in);
}

// create a new "function" object in 5 lines of code:
Func<String, Integer> parseInt = new Func<String, Integer> {
    public Integer apply(String in) {
        return Integer.parseInt(in);
    }
}

诚然，它不如真正的lambda语法那么好，但类型安全，重构的好处和易于解释使得键入这五行在大多数时候是最不糟糕的选择。