JAVA基础｜方法引用

标志性符号“ :: ”

一. 静态方法的引用

使用方法：

类名::静态方法

使用场景：

如果某个Lambda表达式里只是调用一个静态方法，并且前后参数的形式一致，就可以使用静态方法引用。

使用：

我们以下面的代码为例：

Arrays.sort(students, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return Double.compare(o1.getHeight(),o2.getHeight());
    }
});

使用Lambda简化后的形式：

Arrays.sort(students, (o1,o2) -> Double.compare(o1.getHeight(),o2.getHeight()));

那么如何进一步简化呢？

首先，我们随便创建一个类，在里面放上一个比较的静态方法。例如，我们创建一个CompareByData类，在里面创建一个compareByAge的静态方法：

public class CompareByData {
    public static int compareByAge(Student o1,Student o2){
        return o1.getAge()-o2.getAge();
    }
}

接着，我们就可以将Lambda表达式进行简写了，换用静态方法来写：

首先换成调用静态方法：

Arrays.sort(students, (o1,o2) -> CompareByData.compareByAge(o1,o2));

接着进一步简写，将(o1,o2) -> CompareByData.compareByAge(o1,o2))改写为对象名:实例方法的写法：

Arrays.sort(students, CompareByData::compareByAge);

---

二. 实例方法的引用

使用方法：

对象名::实例方法

使用场景：

使用某个Lambda表达式里只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用

使用：

我们还是在上面那个讲解中的CompareByData类中去写一个实例方法：

public int compareByAgeDesc(Student o1,Student o2){
        return o2.getAge()-o1.getAge(); //降序排序
}

 那么我们就可以这么简化了：

CompareByData compare = new CompareByData();
Arrays.sort(students, compare::compareByAgeDesc);

---

三. 特定类型的方法引用

使用方法:

类型::方法

使用场景:

如果某个Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时就可以使用特定类型的方法引用。

使用：

public class Test {
    public static void main(String[] args) {
        String[] names = {"body","angela","Andy","dlei","caocao","Babo","jack","coco"};

        // 要求忽略首字母大小写进行排序
        Arrays.sort(names,new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareToIgnoreCase(o2);
            }
        });

        System.out.println(Arrays.toString(names));
    }
}

例如在上面的代码中，我们写一个忽略首字母大小写进行排序的方法，经过一般简化，我们可以简化成如下形式：

public class Test {
    public static void main(String[] args) {
        String[] names = {"body","angela","Andy","dlei","caocao","Babo","jack","coco"};

        // 要求忽略首字母大小写进行排序
        Arrays.sort(names,(o1,o2) -> o1.compareToIgnoreCase(o2));

        System.out.println(Arrays.toString(names));
    }
}

如上，事实上这仍然不是很简化，根据“特定类型的方法引用“规则我们可以发现，Lambda表达式里只是调用一个实例方法。并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参的，即第一个参数o1是方法的主调，第二个参数o2是作为方法的入参，所以进一步简化为：类型::方法，这里的类型是String类型，所以写成：

Arrays.sort(names,String::compareToIgnoreCase);

---

四. 构造器的引用

使用方法:

类名::new

使用场景:

如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用。

使用:

我们定义一个Car类，以及一个主类，在主类中写一个CreateCar的接口，并在接口中写入创建Car的方法：

public class Test2 {
    public static void main(String[] args) {
        CreateCar cc = new CreateCar() {
            @Override
            public Car create(String name, double price) {
                return new Car(name, price);
            }
        };
        Car c = cc.create("奔驰",49.9);
        System.out.println(c);
    }
}

interface CreateCar {
    Car create(String name,double price);
}

首先对他初步进行简化，得到：

CreateCar cc = (name,price) -> new Car(name, price);

由于该Lambda表达式里只是在创建对象，并且前后参数情况一致，那么就可以使用构造器引用：

CreateCar cc = Car::new;