方法引用 --java学习笔记

静态方法的引用

• 类名::静态方法

使用场景

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

代码举例：

静态方法：

public class comparestu {
    public static int compareheight(student o1, student o2){    //静态方法
        return Double.compare(o1.getHeight(),o2.getHeight());
    }
}

test：

Arrays.sort(s, new Comparator<student>() {  //内部匿名类写法
            @Override
            public int compare(student o1, student o2) {
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        Arrays.sort(s, (student o1, student o2) -> Double.compare(o1.getHeight(),o2.getHeight()));  //简化为lambda表达式
        Arrays.sort(s, (student o1, student o2) -> comparestu.compareheight(o1,o2));    //简化为调用静态方法
        Arrays.sort(s, comparestu::compareheight);  //简化为静态方法引用
        System.out.println(Arrays.toString(s));

实例方法的引用

• 对象名::实例方法

使用场景

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

实例方法引用与静态方法引用类似

代码演示：

首先在之前的工具类中添加一个实例方法：

public class comparestu {
    public static int compareheight(student o1, student o2){    //静态方法
        return Double.compare(o1.getHeight(),o2.getHeight());
    }

    public int compareheight2(student o1, student o2){    //实例方法
        return Double.compare(o1.getHeight(),o2.getHeight());
    }
}

然后如图：

特定类型的方法引用

• 类型::方法

使用场景

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

很抽象，代码演示：

import java.util.Arrays;
import java.util.Comparator;

public class 英文字符串排序 {  //要求对字符串不区分大小写排序
    public static void main(String[] args) {
        String[] strs = {"sdfdsf","dsagdfg","Sdfgfd","Ddfgdsfdf","DFdsfdsf","asdfdsf","Asdfgdf","Csdfdsfdsf,","cdsgfhru"};
        Arrays.sort(strs, new Comparator<String>() {    //匿名内部类写法
            @Override
            public int compare(String o1, String o2) {
                return o1.compareToIgnoreCase(o2);
            }
        });
        System.out.println(Arrays.toString(strs));

        Arrays.sort(strs, (String o1, String o2) -> o1.compareToIgnoreCase(o2));  //lambda表达式写法
        // 注意,此时表达式满足Lambda表达式里只是调用一个实例方法，并且前面参数列表中的第一个参数是作为方法的主调，后面的所有参数都是作为该实例方法的入参
        //简化--
        System.out.println(Arrays.toString(strs));
        
        Arrays.sort(strs, String::compareToIgnoreCase); //特定类型方法引用
        System.out.println(Arrays.toString(strs));
    }
}

运行结果：

可以看到三种方法的结果是一致的

构造器引用

• 类名::new

使用场景

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

同样代码演示：

现有student类：

public class student implements Comparable<student>{   
    private String name;
    private Double height;
    private int age;

    @Override
    public String toString() {
        return name;
    }
}

有一个专门为了创造学生对象的接口，test：

public class 构造器引用 {
    public static void main(String[] args) {
        createStu c1 = new createStu(){  //匿名内部类写法
            @Override
            public student create(String name, Double height, int age) {
                return new student(name,height,age);
            }
        };
        student s1 = c1.create("小张",175.5,23);

        createStu c2 = (String name, Double height, int age) -> new student(name,height,age);   //简化为lambda表达式
        //此时满足Lambda表达式里只是在创建对象，并且前后参数情况一致
        //再简化--
        student s2 = c2.create("小美",175.5,23);

        createStu c3 = student::new;   //简化为构造器引用
        student s3 = c3.create("小飞",175.5,23);

        System.out.println(s1+" "+s2+" "+s3);
    }

    interface createStu{    //创建student学生对象接口
        student create(String name, Double height, int age);
    }
}

运行结果：

可以看到，三个对象创建都没有问题