寻求有关编译器生成的lambda的文档，以将Java 8中的专用对象转换为通用功能对象

Question

我已经使用Java 8 lambda了几个月，现在才发现一种行为，我不记得在Java文档或编程网站中提到过任何行为。 可以在以下代码中看到：

public class CompilerGeneratedLambdaExample
{
    static <A,R> R callFunction(Function<A,R> function, A arg) {
        return function.apply(arg);
    }

    static int staticFunction_arg_int_return_int(int i) {
        return i;
    }

    public static void main(String [] args) {

        /* (A) This compiles and executes as expected - stack looks like:
         * 
        Thread [main] (Suspended (breakpoint at line 16 in CompilerGeneratedLambdaExample)) 
        CompilerGeneratedLambdaExample.staticFunction_arg_int_return_int(int) line: 16  
        1268650975.apply(Object) line: not available    
        CompilerGeneratedLambdaExample.callFunction(Function<A,R>, A) line: 11  
        CompilerGeneratedLambdaExample.main(String[]) line: 33  
        */

        Object value = callFunction(CompilerGeneratedLambdaExample::staticFunction_arg_int_return_int,new Integer(10)); 
        System.out.println("value type: " + value.getClass().getName());
        System.out.println("value: " + value);

        /* (B) This will not compile- error message is:
        * 
        The method callFunction(Function<A,R>, A) in the type CompilerGeneratedLambdaExample is not applicable for the arguments (IntUnaryOperator, Integer)
        */ 

        IntUnaryOperator specializedFunction = CompilerGeneratedLambdaExample::staticFunction_arg_int_return_int; // OK
        //Object value = callFunction(specializedFunction,new Integer(10)); // produces compiler error quoted above
    }
}

这些评论基于我在Java 1.8遵从级别上使用最新版本的Eclipse Java编译器所看到的内容。 我对情况的总结是：

（A）如果将特殊类型的函数对象作为方法引用传递给需要该类型的泛型对应函数的方法，则编译器将包装处理转换参数和返回值的对象。

（B）但是，如果首先将方法引用分配给特殊类型的变量，然后尝试将该变量传递给需要通用类型的函数，则会出现指示类型不匹配的编译器错误。

行为（A）提供了对特殊功能类型的方法引用进行自动装箱和拆箱的功能，对我正在做的工作非常有用。 如果行为（B）有效，它也将很有用，但是它似乎与Java对象类型系统的一般工作方式不符。

我的问题是–这两种行为在哪里–尤其是行为（A），它在Java文档中对专门功能类型的方法引用提供了自动装箱和拆箱的等效功能，并且在Web上还有关于它们的其他有用的讨论？

Answer 1

问题是您分配给IntUnaryOperator ，而不是Function<Integer, Object> 。 你可以做

Object value2 = callFunction(
        CompilerGeneratedLambdaExample::staticFunction_arg_int_return_int, 
        new Integer(10));

要么

Function<Integer, Object> specializedFunction = 
        CompilerGeneratedLambdaExample::staticFunction_arg_int_return_int;
Object value2 = callFunction(specializedFunction, new Integer(10));

或使用自动装箱

Function<Integer, Object> specializedFunction = 
        CompilerGeneratedLambdaExample::staticFunction_arg_int_return_int;
Object value2 = callFunction(specializedFunction, 10);

至于文档，请参阅JLS-15.27。 Lambda表达式

Answer 2

感谢Elliott的评论。 我将方法引用分配给类型为IntUnaryOperator的变量的原因是，它与方法的签名（staticFunction_arg_int_return_int）与int-> int完全匹配。 我并不想修复它，只是将其作为有关Java工作原理的数据点来展示。 但是您的替代任务提供了另一个数据点，这是非常有价值的。

如果我将此代码（C）添加到main：

    /* (C)  genericForSpecializedFunction - works - stacktrace:
     * 
    Thread [main] (Suspended (breakpoint at line 15 in CompilerGeneratedLambdaExample)) 
    CompilerGeneratedLambdaExample.staticFunction_arg_int_return_int(int) line: 15  
    575593575.apply(Object) line: not available <- lambda   
    CompilerGeneratedLambdaExample.callFunction(Function<A,R>, A) line: 10  
    CompilerGeneratedLambdaExample.main(String[]) line: 67  

    Output:
    genericForSpecializedFunction: testHelp.CompilerGeneratedLambdaExample$$Lambda$2/575593575@14acaea5 <- same lambda
    (C) value type: java.lang.Integer
    (C) value: 10
    */ 

    Function<Integer,Integer> genericForSpecializedFunction = CompilerGeneratedLambdaExample::staticFunction_arg_int_return_int; // OK
    System.out.println("genericForSpecializedFunction: " + genericForSpecializedFunction);
    Object value3 = callFunction(genericForSpecializedFunction,new Integer(10));
    System.out.println("(C) value type: " + value3.getClass().getName());
    System.out.println("(C) value: " + value3)

我看到静态方法staticFunction_arg_int_return_int包裹在lambda中，就像直接传递给callFunction时一样。 实际上，在两种情况下都发生了相同的转换（如果要调用它）。

此外，如果我添加类似于（C）的代码（D），则只能使用直接匹配非专用类型的静态方法：

<code>
    static Integer staticFunction_arg_Integer_return_Integer(Integer i) {
        return i;
    }
    ...
        /* (D) with generic methods - stack
         * 
        Thread [main] (Suspended (breakpoint at line 19 in CompilerGeneratedLambdaExample)) 
        CompilerGeneratedLambdaExample.staticFunction_arg_Integer_return_Integer(Integer) line: 19  
        226710952.apply(Object) line: not available  <- lambda
        CompilerGeneratedLambdaExample.callFunction(Function<A,R>, A) line: 10  
        CompilerGeneratedLambdaExample.main(String[]) line: 84

        Output:
        genericFunction: testHelp.CompilerGeneratedLambdaExample$$Lambda$3/226710952@59fa1d9b <- same lambda
        (D) value type: java.lang.Integer
        (D) value: 10
         */

        Function<Integer,Integer> genericFunction = CompilerGeneratedLambdaExample::staticFunction_arg_Integer_return_Integer; // OK
        System.out.println("genericFunction: " + genericFunction);
        Object value4 = callFunction(genericFunction,new Integer(10));
        System.out.println("(D) value type: " + value4.getClass().getName());
        System.out.println("(D) value: " + value4);
</code>

我看到与（C）完全相同的行为，即使不需要参数或返回值转换也是如此。

最后，如果我添加代码（E）通过将泛型函数分配给特殊类型来反转场景：

<code>
    static int callIntUnaryOperator(IntUnaryOperator function, int arg) {
        return function.applyAsInt(arg);
    }
...

        /* (E) specialiedForGenericFunction - stack
         * 
        Thread [main] (Suspended (breakpoint at line 24 in CompilerGeneratedLambdaExample)) 
        CompilerGeneratedLambdaExample.staticFunction_arg_Integer_return_Integer(Integer) line: 24  
        684874119.applyAsInt(int) line: not available <- lambda
        CompilerGeneratedLambdaExample.callIntUnaryOperator(IntUnaryOperator, int) line: 15 
        CompilerGeneratedLambdaExample.main(String[]) line: 109 

        output:
        specializedForgenericFunction: testHelp.CompilerGeneratedLambdaExample$$Lambda$4/684874119@4501b7af <- same lambda
         */

        IntUnaryOperator specializedForGenericFunction = CompilerGeneratedLambdaExample::staticFunction_arg_Integer_return_Integer; // OK
        System.out.println("specializedForgenericFunction: " + specializedForGenericFunction);
        int value5 = callIntUnaryOperator(specializedForGenericFunction,10);
        //System.out.println("(E) value type: " + value5.getClass().getName());
        System.out.println("(E) value: " + value5);
</code>

一切都与（C）和（D）一样。

我对所有这些的解释是：

（1）方法引用的功能类型不是方法引用固有的，并且不能完全由所引用的方法确定（非静态方法的正负类实例）。 仅当将方法引用分配给具有与所引用方法的类型（加号或减号实例）兼容的功能类型的变量或函数参数或返回值时，功能类型才会固定。 如果我理解正确的话，有问题的功能类型称为目标类型。

（2）在目标类型与所引用方法的类型（加号或减号实例）兼容但不相同的一个重要情况是，某些参数和/或返回值在原语之间类型不同（拆箱，专用对象）和相应的对象（实例化的通用对象，带盒）。

（3）在这种情况下，对象（通用）不具有原始（专用）类型的特权。 它们的关系是对称的，因此基础方法可能具有原始arg且功能类型具有对象arg，反之亦然，并且对于返回值也是如此。 这意味着装箱和拆箱都可以。

（4）我本来以为出现在示例代码中的堆栈跟踪和打印的功能对象值中的lambda，是存在于执行参数和返回值类型转换（尤其是装箱和拆箱）的基础方法的包装，但现在它们只是方法引用的功能类型的具体实现，具体实现方式取决于变量的类型，函数参数或为其分配的返回类型-目标类型。 这些具体的实现将始终被创建，并且仅在偶有副作用的情况下执行转换（装箱和拆箱）。 实际上，方法引用是源代码实体，就像源代码lambda表达式一样，它们被编译为lambda对象。

我将查看您链接的doc部分，以特别注意对目标类型和方法引用的引用。