在Java8中引用具有不同参数的方法

Question

我想知道方法引用和功能接口的所有这些东西如何在较低级别上工作.最简单的例子是我们有一些List

List<String> list = new ArrayList<>();
list.add("b");
list.add("a");
list.add("c"):

现在我们想用Collections类对它进行排序,所以我们可以调用:

Collections.sort(list, String::compareToIgnoreCase);

但是,如果我们定义自定义比较器,它可能是这样的:

Comparator<String> customComp = new MyCustomOrderComparator<>();
Collections.sort(list, customComp::compare);

问题是Collections.sort有两个参数:List和Comparator.由于Comparator是功能接口,因此可以使用具有相同签名(参数和返回类型)的lambda表达式或方法引用替换它.那么它是如何工作的,我们也可以传递compareTo只引用一个参数并且这些方法的签名不匹配？如何在Java8中翻译方法引用？

Answer 1

从Oracle方法参考教程:

对特定类型的任意对象的实例方法的引用

以下是对特定类型的任意对象的实例方法的引用示例:

String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);

方法引用的等效lambda表达式String::compareToIgnoreCase将具有形式参数列表(String a, String b),其中a和b是用于更好地描述此示例的任意名称.方法引用将调用该方法a.compareToIgnoreCase(b).

但是,::运营商的真正含义是什么？那么,::运营商可以这样描述(从这个SO问题):

方法参考可以以不同的样式获得,但它们都意味着相同:

1. 静态方法(ClassName::methodName)
2. 特定对象的实例方法(instanceRef::methodName)
3. 特定对象的超级方法(super::methodName)
4. 特定类型的任意对象的实例方法(ClassName::methodName)
5. 类构造函数引用(ClassName::new)
6. 数组构造函数引用(TypeName[]::new)

因此,这意味着方法引用String::compareToIgnoreCase属于第二类(instanceRef::methodName),这意味着它可以被转换为(a, b) -> a.compareToIgnoreCase(b).

我相信以下示例进一步说明了这一点.A Comparator<String>包含一个对两个String操作数进行操作并返回一个操作数的方法int.这可以伪描述为(a, b) ==> return int(其中操作数是a和b).如果您以这种方式查看,则以下所有属于该类别:

// Trad anonymous inner class
// Operands: o1 and o2. Return value: int
Comparator<String> cTrad = new Comparator<String>() {
    @Override
    public int compare(final String o1, final String o2) {
        return o1.compareToIgnoreCase(o2);
    }
};

// Lambda-style
// Operands: o1 and o2. Return value: int
Comparator<String> cLambda = (o1, o2) -> o1.compareToIgnoreCase(o2);

// Method-reference à la bullet #2 above. 
// The invokation can be translated to the two operands and the return value of type int. 
// The first operand is the string instance, the second operand is the method-parameter to
// to the method compareToIgnoreCase and the return value is obviously an int. This means that it
// can be translated to "instanceRef::methodName".
Comparator<String> cMethodRef = String::compareToIgnoreCase;

这个很好的答案解释了如何编译lambda函数.在那个答案中,Jarandinor引用了Brian Goetz的以下段落,该文档描述了有关lambda翻译的更多内容.

我们不是生成字节码来创建实现lambda表达式的对象(例如调用内部类的构造函数),而是描述构造lambda的配方,并将实际构造委托给语言运行库.该配方在invokedynamic指令的静态和动态参数列表中进行编码.

基本上这意味着本机运行时决定如何转换lambda.

Brian继续说道:

方法引用的处理方式与lambda表达式相同,只是大多数方法引用不需要被置于新方法中; 我们可以简单地为引用的方法加载一个常量方法句柄并将其传递给metafactory.

所以,lambdas被贬低为一种新方法.例如

class A {
    public void foo() {
        List<String> list = ...
        list.forEach( s -> { System.out.println(s); } );
    }
}

上面的代码将被解雇为这样的东西:

class A {
    public void foo() {
        List<String> list = ...
        list.forEach( [lambda for lambda$1 as Consumer] );
    }

    static void lambda$1(String s) {
        System.out.println(s);
    }
}

但是,Brian也在文档中解释了这一点:

如果desugared方法是实例方法,则接收器被认为是第一个参数

Brian继续解释lambda的剩余参数作为参数传递给被引用的方法.

因此,在Moandji Ezana的这篇文章的帮助下,compareToIgnoreCase作为一个的desugaring Comparator<String>可以分解为以下步骤:

• Collections#sort对于List<String>需要一个Comparator<String>
• Comparator<String>是与该方法的功能接口,int sort(String, String)相当于BiFunction<String, String, Integer>
• 因此,比较器实例可以由BiFunction兼容的lambda提供:(String a, String b) -> a.compareToIgnoreCase(b)
• String::compareToIgnoreCase是指一个带String参数的实例方法,因此它与上面的lambda兼容:String a成为接收者并String b成为方法参数

编辑:从OP输入后我添加了一个解释desugaring的低级示例