Java基础-JDK8新特性-方法引用

---

1. 静态方法引用

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

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

public class StaticTest {
    public static void main(String[] args) {
        // 目标：掌握静态方法的引用
        Student[] students = new Student[4];
        students[0] = new Student("张三", 169.5, 23);
        students[1] = new Student("李四", 163.8, 26);
        students[2] = new Student("王五", 163.8, 27);
        students[3] = new Student("照率", 167.5, 24);
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });
        // 使用Lambda形式简化
//        Arrays.sort(students, (o1, o2) -> o1.getAge() - o2.getAge());
        // 使用静态方法简化
//        Arrays.sort(students, (o1, o2) -> CompareByData.compareByAge(o1, o2));
        Arrays.sort(students, CompareByData::compareByAge);
        System.out.println(Arrays.toString(students));
    }
}

2. 实例方法引用

类名::实例方法。
使用场景：如果某个Lambda表达式里只是调用了一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用。

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

public class ExampleTest {
    public static void main(String[] args) {
        // 目标：掌握实例方法的引用
        Student[] students = new Student[4];
        students[0] = new Student("张三", 169.5, 23);
        students[1] = new Student("李四", 163.8, 26);
        students[2] = new Student("王五", 163.8, 27);
        students[3] = new Student("照率", 167.5, 24);

//        Arrays.sort(students, (o1, o2) -> CompareByData.compareByAge(o1, o2));
        // 实例方法引用
        CompareByData compareByData = new CompareByData();
        Arrays.sort(students, compareByData::compareByAgeDesc);
        System.out.println(Arrays.toString(students));
    }
}

3. 特定类型方法的引用

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

public class SpecificTest {
    public static void main(String[] args) {
        // 目标：掌握特定方法的引用
        String[] names = {"boby", "angela", "Andy", "dlei", "caocao", "Babo", "jack", "Cici"};

        // 排序（默认是按照字符串的首字母编号进行升序排序的）
        Arrays.sort(names);
        System.out.println(Arrays.toString(names));

        // 要求忽略首字母大小写进行排序
        // compareToIgnoreCase 忽略大小写进行比较
//        Arrays.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2));
        Arrays.sort(names, String::compareToIgnoreCase);
        System.out.println(Arrays.toString(names));
    }
}

4. 构造器方法的引用

类名::new。
使用场景：如果Lambda表达式里只创建对象，并且前后参数情况一致，就可以使用构造器引用。

public class Car {
    private String name;
    private double price;

    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

public class ConstructorTest {
    public static void main(String[] args) {
        // 目标：掌握构造器引用

        // 创建接口的匿名内部类对象
//        CreateCar createCar = new CreateCar() {
//            @Override
//            public Car create(String name, double price) {
//                return new Car(name, price);
//            }
//        };
//        CreateCar createCar = (name, price) -> new Car(name, price);
        // 构造器引用
        CreateCar createCar = Car::new;
        Car car = createCar.create("梅赛德斯", 49.9);
        System.out.println(car);
    }
}

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