方法引用精讲-优快云博客

本文链接：https://blog.youkuaiyun.com/ITITII/article/details/84374779

方法引用

方法引用是lambda表达式的一种特殊形式，如果正好有某个方法满足一个lambda表达式的形式，那就可以将这个lambda表达式用方法引用的方式表示，但是如果这个lambda表达式的比较复杂就不能用方法引用进行替换。实际上方法引用是lambda表达式的一种语法糖。前面我们也说过关于函数式接口的实例方式有两种：1.lambda表达式。2.方法引用。

方法引用分类：

类名::静态方法名

为了演示，我这里建一个类：

class Person{
    private String name;
    private int age;
    public Person(String name,Integer age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public static int comparePersonByAge(Person person, Person person1){
        return person.getAge() - person1.getAge();
    }
}

然后我们创建三个Person对象，并封装成一个集合，根据年龄进行排序输出到控制台。

public class TestMethodReference {
    public static void main(String[] args) {
        Person person1 = new Person("lisi",8);
        Person person2 = new Person("zhangsan",2);
        Person person3 = new Person("xiaohua",10);
        List<Person> persons = Arrays.asList(person1,person2,person3);
        persons.sort((o1,o2)->o1.getAge()-o2.getAge());
        persons.forEach(o1->System.out.println(o1));
    }
}

通过上面的方法，我们可以发现，persons.sort();方法接收的是一个函数式接口Comparator，该接口中有一个int compare(T o1, T o2);方法。因此上面的方式是通过函数式接口来实例化该函数式接口的。当然我们也可以改为方法引用的方式来实例化该函数式接口：

public class TestMethodReference {
    public static void main(String[] args) {
        Person person1 = new Person("lisi",8);
        Person person2 = new Person("zhangsan",2);
        Person person3 = new Person("xiaohua",10);
        List<Person> persons = Arrays.asList(person1,person2,person3);
        persons.sort(Person::comparePersonByAge);
        persons.forEach(System.out::println);
    }
}

这段代码就使用了静态方法引用，同样能和上面的达成一样的结果。那么为什么使用Person类中的静态方法就能实例化Comparator接口呢？

我们知道Comparator函数式接口中的compare方法接收两个参数，而且恰好Person的静态方法comparePersonByAge方法也是接收两个参数。其实Java虚拟机就是把compare接收的两个参数传给comparePersonByAge方法，然后compare放法的实现就是使用comparePersonByAge方法体进行实现。那么我们就可以说，方法引用就是lambda表达式的一块语法糖。

对象::实例方法名

我们上面定义的Person类中，在Person类中写了一个比较方法comparePersonByAge从语法上面来说是没有问题的。但是从设计上来说，该种方式是错误的。也是不建议这样定义使用的。因为一个Person类中的方法最好不要出现接受两Person对象。那么对于上面的比较我们可以单独写一个比较器类：

class PersonComparetor{
    public int compareByAge(Person person1,Person person2){
        return person1.getAge()-person2.getAge();
    }
}

定义好比较器类后，我们就可以再此对上面的比较进行改写：

public class TestMethodReference {
    public static void main(String[] args) {
        Person person1 = new Person("lisi",8);
        Person person2 = new Person("zhangsan",2);
        Person person3 = new Person("xiaohua",10);
        List<Person> persons = Arrays.asList(person1,person2,person3);
        persons.sort(new PersonComparetor()::compareByAge);
        persons.forEach(o1->System.out.println(o1));
    }
}

通过改写后，我们就可以发现，我们使用的是new PersonComparetor()::compareByAge来替换lambda表达式，使用的是一个比较器对象来引用他的一个实例方法compareByAge。这种方式和上面一样，Java虚拟机会把compare方法接受的两个参数传给compareByAge方法，并以compareByAge体作为实现。

类名::实例方法名

如果我们想满足设计模式和语法同样正确，还是希望在Person类中定义他自己的比较方法，那么我们可以这样改写Person类：

class Person{
    private String name;
    private int age;
    public Person(String name,Integer age){
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public int compareByAge(Person person){
        return this.getAge() - person.getAge();
    }
}

这种定义方式，就能满足设计模式和语法同样错误，但是我们发现compareByAge方法接收的参数只有一个啦。那这种方式能否满足Comparator函数式接口的实例呢？那么我们不妨来试一下：

public class TestMethodReference {
    public static void main(String[] args) {
        Person person1 = new Person("lisi",8);
        Person person2 = new Person("zhangsan",2);
        Person person3 = new Person("xiaohua",10);
        List<Person> persons = Arrays.asList(person1,person2,person3);
        persons.sort(Person::compareByAge);
        persons.forEach(o1->System.out.println(o1));
    }
}

通过这段代码的运行，我们发现同样能得到相同的结果。这种方式究竟是怎么回事，该方法只能接收一个参数，然而compare方法接收的是两个参数，怎么用一个接收一个参数的compareByAge方法就能实例化呢？

其实是这样的：上面已经说了compare方法是接收两个参数，然而compareByAge方法接收一个参数。但是我们要记住compareByAge是一个实例方法，如果要顶用该方法就得通过Person对象才能调用该方法，那么答案就出来啦。Java虚拟机是把compare方法的第一个参数作为调用compareByAge方法的Person对象，把compare方法的第二个参数作为compareByAge的参数传入。是不是很神奇哇！

类名::new

该方式也叫构造方法引用；该方法的应用场景就是如果需要某个类的对象，就可以使用该方式；下面就给出演示吧：

public class TestMethodReference {
    public static void main(String[] args) {
        TestMethodReference demo = new TestMethodReference();
        System.out.println(demo.getPerson(Person::new));
        
    }
    
    public Person getPerson(Supplier<Person> supplier){
        return supplier.get();
    }
}

主意：该种方式使用的是默认构造，因为supplier接口中的get不需要接收任何参数，因此如果实例化该Supplier函数式接口，那么构造方法也得不接收任何参数。那么就只能使用默认构造。

下面给出一种不使用默认构造的方法引用方式：

public class TestMethodReference {
    public static void main(String[] args) {
        TestMethodReference demo = new TestMethodReference();
        System.out.println(demo.getPerson(Person::new,"xiaolizi",20));

    }

    public Person getPerson(BiFunction<String,Integer,Person> function,String name,Integer age){
        return function.apply(name,age);
    }
}

这种方法式就没有使用默认构造，因为BiFunction函数式接口的apply方法需要接收连个参数。使用构造方法，就得该构造方法也接收两个参数的构造方法才能实例化该函数式口。

关于方法引用就简单的介绍到这里！