JDK8新特性之Lambda表达式和方法引用-CSDN博客

本文链接：https://blog.csdn.net/m0_64046816/article/details/133522941

JDK8新特性之Lambda表达式和方法引用

Lambda表达式
方法引用

Lambda表达式

Lambda表达式的作用就是简化匿名内部类的写法，如下是其标准格式:

(方法的形参列表) -> {
  方法体代码
}

Lambda表达式的省略规则

参数的数据类型可以省略不写
如果形参列表中只有一个参数时小括号可以不写
如果方法体只有一行代码时，花括号可以省略不写，但是方法体代码后面的分号一定要省略
如果方法体只有一行代码，并且是一条带有return的语句，那么return必须去掉

注意事项

Lambda表达式不能简化所有形式的匿名内部类，只能简化函数式接口的匿名内部类
函数式匿名内部类就是一个接口中有且仅有一个抽象方法

如下是针对省略规则的例子演示
未简化之前的函数式接口匿名内部类

public class Test {
    public static void main(String[] args) {
        bird bird = new bird() {
            @Override
            public void fly(String name) {
               return name+"正在飞~~";
            }
        };
        System.out.println(bird.fly("小明"));
    }
}

interface bird{
    String fly(String name);
}

使用Lambda表达式简化后的函数式接口匿名内部类

public class Test {
    public static void main(String[] args) {
        // Lambda表达式未简化之前
        bird b = (String name) -> {
            return name+"正在飞~~";
        };

        // 参数的数据类型可以省略不写
        bird b1 = (name) -> {
            return name+"正在飞~~";
        };

        // 如果形参列表中只有一个参数时小括号可以不写
        bird b2 = name -> {
            return name+"正在飞~~";
        };

        // 如果方法体只有一行代码时，花括号可以省略不写，但是方法体代码后面的分号一定要省略
        // 如果方法体只有一行代码，并且是一条带有return的语句，那么return必须去掉
        bird b3 = name -> name+"正在飞~~";
    }
}

interface bird{
    String fly(String name);
}

方法引用

方法引用的作用是进一步简化Lambda表达式，其标志是使用"::"符号
静态方法引用

先在一个类中定义一个静态方法，在静态方法里重写我们所要简化的匿名内部类的方法体代码
在要简化的Lambda表达式的形参列表要和静态方法中的形参列表一模一样
使用类名:方法名的形式简化Lambda表达式

public class Demo {
    public static void main(String[] args) {
        // 按照对象年龄升序排序
        Student students[] = new Student[3];
        students[0] = new Student("小明",18);
        students[1] = new Student("小白",16);
        students[2] = new Student("小王",20);
        // 原式
        Arrays.sort(students,(o1, o2) -> {
            return o1.getAge()-o2.getAge();
        });

        // 静态方法引用简化后的式子
        Arrays.sort(students,Sort::sortAge);
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

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

实例方法引用

在一个类中定义一个实例方法，里面重写我们所要简化的匿名内部类的方法体代码
在要简化的Lambda表达式的形参列表要和实例方法中的形参列表一模一样
最后把Lambda表达式该为对象::方法名即可

public class Demo {
    public static void main(String[] args) {
        // 按照对象年龄升序排序
        Student students[] = new Student[3];
        students[0] = new Student("小明",18);
        students[1] = new Student("小白",16);
        students[2] = new Student("小王",20);
        // 原式
        Arrays.sort(students,(o1, o2) -> {
            return o1.getAge()-o2.getAge();
        });

        // 静态方法引用简化后的式子
        Arrays.sort(students,new Instance()::sortAge);
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

class Instance{
    public int sortAge(Student o1, Student o2){
        return o1.getAge() - o2.getAge();
    }
}

特定类型方法引用

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

public class Demo {
    public static void main(String[] args) {
        String names[] = {"body","angela","Andy","daling","caocao","Bob","jack","Cici"};

        // 要求忽略首字符大小写进行排序 使用o1.compareToIgnoreCase(o2)字符串提供的忽略大小写比较大小
        // 原式
        Arrays.sort(names,((o1, o2) -> o1.compareToIgnoreCase(o2)));

        // 使用特定方法引用简化后的Lambda表达式
        Arrays.sort(names,String::compareToIgnoreCase);

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

构造器引用

如果Lambda表达式只是为了创建一个对象，并且前后参数一致，就可以使用构造器引用
最后把Lambda表达式改为类名::new即可

public class Demo {
    public static void main(String[] args) {
        // 原式
        constructor cc = (name,age) -> new Student(name,age);

        // 使用构造器引用简化后的Lambda表达式
        constructor c = Student::new;

        Student student = c.create("乾巧", 18);
        System.out.println(student);
    }
}