JavaSE——JDK8新特性（2/2）：方法引用（静态方法的引用、实例方法的引用、特定类型的方法引用、构造器引用）

目录

静态方法的引用

实例演示

代码部分 

实例方法的引用

实例演示

代码部分

特定类型的方法引用

实例演示

代码部分 

构造器引用

语法演示

代码部分 

---

JDK8新特性：方法引用——进一步简化Lambda表达式的

• 方法引用的标志性符号“ :: ”

先来看静态方法的引用

静态方法的引用

• 类名 :: 静态方法。

使用场景

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

实例演示

原始写法：

用Lambda简化之后：

 此时定义了一个类中的一个静态方法是实现排序规则的：

那么Lambda简化之后的式子就可以这么写：

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

使用引用之后：

代码部分 

public class Test {
    public static void main(String[] args){
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精",169.5,24);
        students[1] = new Student("紫霞",163.8,25);
        students[2] = new Student("紫霞",163.8,25);
        students[3] = new Student("至尊宝",167.5,21);

        //原始写法：对数组中的学生对象，按照年龄升序排序
//        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 );
        
    }
}

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

实例方法的引用

• 对象名 :: 实例方法

使用场景

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

实例演示

先在一个类中定义一个实例方法：

然后到Test类中调用该方法，并经由Lambda表达式简化：

实例方法引用：

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

代码部分

public class Test {
    public static void main(String[] args){
        Student[] students = new Student[4];
        students[0] = new Student("蜘蛛精",169.5,24);
        students[1] = new Student("紫霞",163.8,25);
        students[2] = new Student("紫霞",163.8,25);
        students[3] = new Student("至尊宝",167.5,21);

        CompareByData compare = new CompareByData();
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o2.getAge() - o1.getAge();
//            }
//        });

//        Arrays.sort(students,(o1, o2) -> o2.getAge() - o1.getAge());

//        Arrays.sort(students,(o1, o2) -> compare.compareByAgeDesc(o1,o2));

        Arrays.sort(students,compare::compareByAgeDesc);
        
    }
}

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

特定类型的方法引用

• 类型 :: 方法

使用场景

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

实例演示

排序一个字符串数组（忽略字符串大小写）

运行结果：

这显然不是我们想要看到的排序效果，所以接下来就要自定义排序规则：

实际上，我们调用方法compareToIgnoreCase，它已经制定好了忽略首字母大小写的排序规则。

运行结果： 

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

进行方法引用之后：

代码部分 

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

        //进行排序（默认按照字符串的首字符编号进行升序排序的
//        Arrays.sort(names);

        //要求忽略首字符大小写进行排序
//        Arrays.sort(names, new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                //制定比较规则， o1 = "Andy" o2 = "angela"
//                return o1.compareToIgnoreCase(o2);
//            }
//        });

//        Arrays.sort(names, (o1, o2)->  o1.compareToIgnoreCase(o2));

        //特定类型方法引用
        Arrays.sort(names,String::compareToIgnoreCase);   //compareToIgnoreCase是String里面的方法

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

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

构造器引用

• 类名 :: new

使用场景

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

语法演示

这里的例子并没有太多的实际意义，重点放在语法的示例

首先定义了一个CreateCar的接口和一个Car类：

然后在main方法里面创建这个接口的匿名内部类对象：

进行简化：

代码部分 

public class Test {
    public static void main(String[] args){
        //1.创建这个接口的匿名内部类对象
//        CreateCar cc = new CreateCar() {
//            @Override
//            public Car create(String name, double price) {
//                return new Car(name,price);
//            }
//        };

//        CreateCar cc = (name, price) ->new Car(name,price); //Lambda表达式简化

        CreateCar cc = Car::new; //构造器引用
        Car c = cc.create("奔驰",49.9);
        System.out.println(c);

    }
}

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


class Car {
    private String name;
    private double price;

    public Car() {
    }

    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;
    }
}

---

END 

---

学习自：黑马程序员——JavaSE课程