Java8新特性 方法引用

在使用Lambda表达式的时候，实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，没有必要再写重复逻辑。

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用，方法引用可以看做是Lambda表达式深层次的表达。

换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

看一个简单的函数式接口以应用Lambda表达式：

@FunctionalInterface
public interface Printable { 
    void print(String str);
}

在Printable接口当中唯一的抽象方法print接收一个字符串参数，目的就是为了打印显示它。通过Lambda来使用它的代码很简单：

public class Demo01PrintSimple {
    private static void printString(Printable data) { 
        data.print("Hello, World!");
    }
    public static void main(String[] args) {
        printString(s ‐> System.out.println(s));
    }
}

printString方法只管调用Printable接口的print方法，main方法通过Lambda表达式指定了函数式接口Printable的具体操作方案为：拿到String（类型可推导，所以可省略）数据后，在控制台中输出它。

这段代码的问题在于，对字符串进行控制台打印输出的操作方案，已经有了现成的实现，那就是System.out对象中的println(String) 方法。Lambda希望做的事情就是调用println(String)方法，不必自己手动调用。省去Lambda的语法格式，只要“引用”过去就好了：

public class Demo02PrintRef {
    private static void printString(Printable data) { 
        data.print("Hello, World!");
    }
    public static void main(String[] args) {
        printString(System.out::println);
    }
}

方法引用符

双冒号 :: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

要求： 实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致。

格式： 使用操作符 :: 将类(或对象) 与 方法名分隔开来。

如下三种主要使用情况：

• 对象::实例方法名
• 类::静态方法名
• 类::实例方法名

语义分析

上例中，System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。对于printString方法的函数式接口参数，对比下面两种写法，完全等效：

• Lambda表达式写法： s -> System.out.println(s);
• 方法引用写法： System.out::println

第一种语义是指： 拿到参数之后经Lambda之手，继而传递给System.out.println方法去处理。
第二种等效写法的语义是指： 直接让System.out中的println方法来取代Lambda。
两种写法的执行效果完全一样，而第二种方法引用的写法复用了已有方案，更加简洁。

推导与省略

如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。

函数式接口是Lambda的基础，而方法引用是Lambda的孪生兄弟。

下面这段代码将会调用println方法的不同重载形式，将函数式接口改为int类型的参数：

@FunctionalInterface
public interface PrintableInteger { 
    void print(int str);
}

由于上下文变了之后可以自动推导出唯一对应的匹配重载，所以方法引用没有任何变化：

public class Demo03PrintOverload {
    private static void printInteger(PrintableInteger data) { 
        data.print(1024);
    }
    public static void main(String[] args) {
        printInteger(System.out::println);
    }
}

这次方法引用将会自动匹配到println(int)的重载形式。

对象名引用成员方法

这是最常见的一种用法，与上例相同。如果一个类中已经存在了一个成员方法：

public class MethodRefObject {
    public void printUpperCase(String str) { 
        System.out.println(str.toUpperCase());
    }
}

函数式接口仍然定义为：

@FunctionalInterface
public interface Printable { 
    void print(String str);
}

那么当需要使用这个printUpperCase成员方法来替代Printable接口的Lambda的时候，已经具有了MethodRefObject类的对象实例，则可以通过对象名引用成员方法，代码为：

public class Demo04MethodRef {
    private static void printString(Printable lambda) { 
        lambda.print("Hello");
    }
    public static void main(String[] args) {
        MethodRefObject obj = new MethodRefObject(); 
        printString(obj::printUpperCase);
    }
}

通过类名称引用静态方法

在java.lang.Math类中已经存在静态方法abs，当我们需要通过Lambda来调用该方法时，有两种写法。

首先是函数式接口：

@FunctionalInterface
public interface Calcable { 
    int calc(int num);
}

对比：

public class Demo05Lambda {
    private static void method(int num, Calcable lambda) { 
        System.out.println(lambda.calc(num));
    }
    public static void main(String[] args) {
        // Lambda写法：
        method((‐10, n) ‐> Math.abs(n));
        // 方法引用：
        method(‐10, Math::abs);
    }
}

通过super引用成员方法

如果存在继承关系，当Lambda中需要出现super调用时，也可以使用方法引用进行替代。

函数式接口：

@FunctionalInterface
public interface Greetable { 
    void greet();
}

父类 Human ：

public class Human {
    public void sayHello() {
        System.out.println("Hello!");
    }
}

子类 Man ，其中使用了Lambda调用父类的sayHello方法：

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好，我是Man!");
    }
    // 定义方法method，参数传递Greetable接口 
    public void method(Greetable g){
        g.greet();
    }
    public void show(){
        // Lambda写法：
        method(() ‐> super.sayHello());
        // 方法引用：
        method(super::sayHello);
    }
}

通过this引用成员方法

this代表当前对象，如果需要引用的方法就是当前类中的成员方法，那么可以使用this::成员方法的格式来使用方法引用。

函数式接口：

@FunctionalInterface
public interface Richable { 
    void buy();
}

丈夫 Husband 类：

方法beHappy调用了方法marry，后者的参数为函数式接口Richable，所以需要一个Lambda表达式。

public class Husband {
    private void buyHouse() {
        System.out.println("买套房子");
    }
    private void marry(Richable lambda) { 
        lambda.buy();
    }
    public void beHappy() {
        // Lambda写法：
        marry(() ‐> this.buyHouse());
        // 方法引用：
        marry(this::buyHouse);
    }
}

类的构造器引用

由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用类名称::new的格式表示。

Person 类：

public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    // get方法...
    // set方法...
}

创建 Person 对象的函数式接口：

public interface PersonBuilder {
    Person buildPerson(String name); 
}

对比：

public class Demo09Lambda {
    public static void printName(String name, PersonBuilder builder) { 
        System.out.println(builder.buildPerson(name).getName());
    }
    public static void main(String[] args) {
        // Lambda写法：
        printName("赵丽颖", name ‐> new Person(name));
        // 方法引用：
        printName("赵丽颖", Person::new);
    }
}

数组的构造器引用

数组也是 Object 的子类对象，所以同样具有构造器，只是语法稍有不同。

如果对应到Lambda的使用场景中时，需要一个函数式接口：

@FunctionalInterface
public interface ArrayBuilder { 
    int[] buildArray(int length);
}

对比：

public class Demo11ArrayInitRef {
    private static int[] initArray(int length, ArrayBuilder builder) { 
        return builder.buildArray(length);
    }
    public static void main(String[] args) {
        // Lambda写法：
        int[] array = initArray(10, length ‐> new int[length]);
        // 方法引用：
        int[] array = initArray(10, int[]::new);
    }
}