Java：Lambda表达式、方法引用

文章目录

- 1、Lambda表达式
- - 1.1 Lambda表达式体验
  - 1.2 Lambda表达式的省略形式
  - 1.3 Lambda表达式练习
- 2、方法引用体验
- 3、方法引用符
- 4、引用静态方法
- 5、引用对象的实例方法
- 6、引用类的实例方法
- 7、引用构造方法
- 8、引用数组的构造方法
- 9、方法引用练习
- - 9.1 练习1
  - 9.2 练习2
  - 9.3 练习3
- 10、方法引用总结

学习方法引用之前先学匿名内部类和Lambda表达式。以下代码基于JDK11编写。

1、Lambda表达式

函数式编程：忽略面向对象的复杂语法，强调做什么，而不是谁去做。
函数式接口：有且只有一个抽象方法的接口叫做函数式接口，接口上方可加@Functioonalinterface

Lambda表达式的基本作用：用来简化匿名内部类的书写，Lambda表达式只能简化函数式接口的匿名内部类的写法。

Lambda表达式有什么使用前提：必须是接口的匿名内部类，接口中只能有一个抽象方法。

Lambda的好处：Lambda是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码，它可以写出更简洁、更灵活的代码，作为一种更紧凑的代码风格，使Java语言表达能力得到了提升。

Lambda表达式语法：() -> {}

()：形参
->：固定格式
{}：方法的方法体

1.1 Lambda表达式体验

public class LambdaDemo01 {
    public static void main(String[] args) {

        /**
         *  1.利用匿名内部类的形式去调用下面的方法(以前的调用方式)
         *  调用一个方法的时候，如果方法的形参是一个接口，那么我们要传递这个接口的实现类对象
         *  如果实现类对象只要用到一次，就可以用匿名内部类的形式进行书写
         */
        method(new Swiming() {
            @Override
            public void swim() {
                System.out.println("正在游泳-这是匿名内部类方式");
            }
        });

        /**
         *  2.利用Lambda表达式的形式去调用下面的方法
         */
        method(() ->{
            System.out.println("正在游泳-这是Lambda表达式格式");
        });
    }

    public static void method(Swiming s){
        s.swim();
    }
}

// 这里即使不写@Functioonalinterface也是函数式接口，因为接口中只有一个抽象方法
interface Swiming{
    void swim();
}

1.2 Lambda表达式的省略形式

参数类型可以省略不写。
如果只有一个参数，参数类型可以省略，同时()也可以省略。
如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略。

public class LambdaDemo02 {
    public static void main(String[] args) {
        // 需求：降序排序

        Integer[] arr = {10, 2, 5, 1, 4, 3, 6, 7, 8, 9};

        System.out.println("------------Lambda表达式完整格式----------");
        //Lambda表达式完整格式
        Arrays.sort(arr,(Integer o1, Integer o2) -> {
//            return o1 - o2; //升序排序
            return o2-o1;  //降序排序
        });
        System.out.println(Arrays.toString(arr));


        System.out.println("------------Lambda表达式省略格式----------");

        /**
         * Lambda表达式省略写法
         * 如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略
         */
        Arrays.sort(arr,((o1, o2) -> o2-o1));
        System.out.println(Arrays.toString(arr));
    }
}

1.3 Lambda表达式练习

需求：定义数组并存储一些字符串，利用Arrays中的sort方法进行排序

思路：按照字符串长度排序，短的在前，长的在后，不比较里面的内容。

public class LambdaDemo03 {
    public static void main(String[] args) {
        //需求：定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
        //思路:按照字符串长度排序，短的在前，长的在后，不比较里面的内容
        String[] strings = {"abc","a","ab","123abc","123","abab","aaaaaaaa","aaaaa"};

        System.out.println("------------Lambda表达式完整格式(升序)----------");
        Arrays.sort(strings,(String o1, String o2) ->{
            return o1.length() - o2.length();
        });
        System.out.println(Arrays.toString(strings));

        System.out.println("------------Lambda表达式省略格式(倒叙)----------");
        Arrays.sort(strings,((o1, o2) -> o2.length() - o1.length()));
        System.out.println(Arrays.toString(strings));
    }
}

2、方法引用体验

（1）方法引用的出现原因

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要。

那我们又是如何使用已经存在的方案的呢？这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案。

（2）方法引用的使用条件

被引用的方法需要已经存在，可以是Java已经写好的，也可以是一些第三方的工具类
被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
被引用方法的功能需要满足当前的要求

（3）代码演示

public class MethodReferenceDemo01 {
    public static void main(String[] args) {
        // 需求：创建一个数组，进行降序排列
        Integer[] arr = {3, 5, 4, 1, 6, 2};

        System.out.println("------------匿名内部类方式-----------");
        /**
         * 匿名内部类方式
         */
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        System.out.println(Arrays.toString(arr));


        System.out.println("------------lambda表达式方式-----------");
        /**
         * lambda表达式方式
         * 因为第二个参数的类型Comparator是一个函数式接口,所以可以使用lambda表达式
         */
        Arrays.sort(arr,(Integer o1,Integer o2) -> {
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr));


        System.out.println("------------方法引用方式-----------");
        /**
         * 1.引用处需要是函数式接口
         * 2.被引用的方法需要已经存在
         * 3.被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
         * 4.被引用方法的功能需要满足当前的要求
         */
        Arrays.sort(arr,MethodReferenceDemo01::subtraction);
        System.out.println(Arrays.toString(arr));
    }
    
    // 被引用的方法可以是Java已经写好的，也可以是一些第三方的工具类
    public static int subtraction(int num1, int num2) {
        return num2 - num1;
    }
}

3、方法引用符

（1）方法引用符

:: 该符号为引用运算符，而它所在的表达式被称为方法引用

（2）推导与省略

如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
如果使用方法引用，也是同样可以根据上下文进行推导
方法引用是Lambda的孪生兄弟

4、引用静态方法

引用类方法，其实就是引用类的静态方法

类方法（Class Method）是指使用 static 关键字修饰的方法。

（1）格式

类名::静态方法

（2）示例

Integer::parseInt

Integer类的方法：public static int parseInt(String s) 将此String转换为int类型数据

（3）练习描述

需求：集合中有以下数字，要求把他们都变成int类型
“1”,“2”,“3”,“4”,“5”

（4）代码演示

public class MethodReferenceDemo02 {
    public static void main(String[] args) {

        // 1.创建集合并添加元素
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5");

        // 2.把他们都变成int类型，使用map进行类型的转换(String->Integer)
        System.out.println("-----------匿名内部类方式------------");
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                return i;
            }
        }).forEach(s-> System.out.println(s));

        System.out.println("-----------方法引用方式------------");
        list.stream()
                .map(Integer::parseInt)
                .forEach(s-> System.out.println(s));
    }
}

使用说明：Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数

5、引用对象的实例方法

引用对象的实例方法，其实就是引用类中的成员方法

成员方法包括实例方法和静态方法。

public class MyClass {
// 实例变量
private int myVariable;

// 实例方法
public void instanceMethod() {
  // 这是一个实例方法，可以访问实例变量
  System.out.println("This is an instance method.");
}

// 静态方法
public static void staticMethod() {
  // 这是一个静态方法，不能访问实例变量
  System.out.println("This is a static method.");
}
}

（1）格式
其他类：其他类对象::方法名
本类：this::方法名(引用处不能是静态方法)
父类：super::方法名(引用处不能是静态方法)

（2）示例

“HelloWorld”::toUpperCase

String类中的方法：public String toUpperCase() 将此String所有字符转换为大写

（3）练习描述

    需求：
        集合中有一些名字，按照要求过滤数据
        数据："张无忌","周芷若","赵敏","张强","张三丰"
        要求：只要以张开头，而且名字是3个字的

（4）代码演示

其他类的成员方法

public class StringOperation {
    public boolean stringJudge(String s){
        return s.startsWith("张") && s.length() == 3;
    }
}

测试

public class MethodReferenceDemo03 {
    public static void main(String[] args) {
        
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰");

        //3.过滤数据（只要以张开头，而且名字是3个字的）


        System.out.println("------------匿名内部类方式--------------");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张")&&s.length() == 3;
            }
        }).forEach(s-> System.out.println(s));


        System.out.println("------------Lambda表达式方式--------------");
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));

        System.out.println("------------方法引用方式：引用其他类的成员方法--------------");
        StringOperation so = new StringOperation();
        list.stream().filter(so::stringJudge)
                .forEach(s -> System.out.println(s));

        System.out.println("------------方法引用方式：引用本类的成员方法-----------------");
        // 下面的这个代码在main中，main方法是静态的，而静态方法中是没有this的，
        // 所以会报错cannot be referenced from a static context
/*        list.stream().filter(this.stringJudge)
                .forEach(s -> System.out.println(s));*/
        list.stream().filter(new MethodReferenceDemo03()::stringJudge)
                .forEach(s -> System.out.println(s));
    }
    
    public boolean stringJudge(String s){
        return s.startsWith("张") && s.length() == 3;
    }
}

使用说明：Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数

6、引用类的实例方法

引用类的实例方法，其实就是引用类中的成员方法

（1）格式

类名::成员方法

（2）示例

String::substring

public String substring(int beginIndex,int endIndex)

从beginIndex开始到endIndex结束，截取字符串。返回一个子串，子串的长度为endIndex-beginIndex

（3）练习描述

需求：合里面一些字符串，要求变成大写后进行输出

（4）代码演示

public class MethodReferenceDemo05 {
    public static void main(String[] args) {
        /*
        匿名内部类中的抽象方法形参的详解：
        第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
                    在Stream流当中，第一个参数一般都表示流里面的每一个数据。
                    假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法

        第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法

        局限性：
            不能引用所有类中的成员方法。
            是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。

       */

        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list, "aaa", "bbb", "ccc", "ddd");
        //3.变成大写后进行输出,使用map进行转换

        System.out.println("------------匿名内部类方式--------------");
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s -> System.out.println(s));


        System.out.println("------------方法引用方式-----------------");
        //拿着流里面的每一个数据，去调用String类中的toUpperCase方法，方法的返回值就是转换之后的结果。
        list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
    }
}

使用说明：Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数。

7、引用构造方法

引用构造器，其实就是引用构造方法

（1）格式

类名::new

（2）示例

Student::new

（3）练习描述

需求：集合里面存储姓名和年龄，要求封装成Student对象并收集到List集合中

（4）代码演示

public class MethodReferenceDemo04 {
    public static void main(String[] args) {

        //1.创建集合对象
        ArrayList<String> list = new ArrayList<>();
        //2.添加数据
        Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13", "张强,20", "张三丰,100", "张翠山,40", "张良,35", "王二麻子,37", "谢广坤,41");
        //3.封装成Student对象并收集到List集合中，使用map进行类型转换（String --> Student）

        System.out.println("------------匿名内部类方式--------------");
        List<Student> newList = list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String[] arr = s.split(",");
                String name = arr[0];
                int age = Integer.parseInt(arr[1]);
                return new Student(name, age);
            }
        }).collect(Collectors.toList());
        System.out.println(newList);

        System.out.println("------------方法引用方式-----------------");
        List<Student> newList2 = list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(newList2);
    }
}

使用说明：Lambda表达式被构造器替代的时候，它的形式参数全部传递给构造器作为参数。

8、引用数组的构造方法

（1）格式

数据类型[]::new

（2）示例

int[]::new

（3）目的

创建一个指定类型的数组

（4）练习描述

需求：集合中存储一些整数，收集到数组当中
细节：数组的类型，需要跟流中数据的类型保持一致。

（5）代码演示

public class MethodReferenceDemo06 {
    public static void main(String[] args) {

        //1.创建集合并添加元素
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5);
        //2.收集到数组当中
        System.out.println("------------匿名内部类方式--------------");
        Integer[] arr = list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });
        System.out.println(Arrays.toString(arr));

        System.out.println("------------方法引用方式-----------------");
        Integer[] arr2 = list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr2));
    }
}

9、方法引用练习

9.1 练习1

需求：
     集合中存储一些字符串的数据，比如：张三,23。
     收集到Student类型的数组当中

代码实现

public class MethodReferenceDemo07 {
    public static void main(String[] args) {
        //1.创建集合并添加元素
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13", "张强,20", "张三丰,100", "张翠山,40", "张良,35", "王二麻子,37", "谢广坤,41");
        //2.先把字符串变成Student对象，然后再把Student对象收集起来
        // map之后，流里的数据已经变为Student了，所以toArray要转为Student类型的数组
        Student[] arr = list.stream().map(Student::new).toArray(Student[]::new);
        // 打印数组
        System.out.println(Arrays.toString(arr));
    }
}

9.2 练习2

需求：
    创建集合添加学生对象
    学生对象属性：name，age
要求：
    获取姓名并放到数组当中
    使用方法引用完成
技巧：
    1.现在有没有一个方法符合我当前的需求
    2.如果有这样的方法，这个方法是否满足引用的规则
    静态   类名：：方法名
    成员方法
    构造方法  类名：：new

代码实现

public class MethodReferenceDemo08 {
    public static void main(String[] args) {
        // 1.创建集合
        ArrayList<Student> list = new ArrayList<>();
        // 2.添加元素
        list.add(new Student("zhangsan",23));
        list.add(new Student("lisi",24));
        list.add(new Student("wangwu",25));
        // 3.获取姓名放到数组当中
        System.out.println("------------匿名内部类方式--------------");
        String[] arr = list.stream().map(new Function<Student, String>() {
            @Override
            public String apply(Student student) {
                return student.getName();
            }
        }).toArray(String[]::new);
        System.out.println(Arrays.toString(arr));

        System.out.println("------------方法引用方式-----------------");
        String[] arr2 = list.stream().map(Student::getName).toArray(String[]::new);
        System.out.println(Arrays.toString(arr2));
    }
}

9.3 练习3

需求：
    创建集合添加学生对象
    学生对象属性：name，age
要求：
    把姓名和年龄拼接成：张三-23的字符串，并放到数组当中
    使用方法引用完成

代码实现

public class MethodReferenceDemo09 {
    public static void main(String[] args) {
        ArrayList<Student> studentList = new ArrayList<>();
        studentList.add(new Student("zhangsan",23));
        studentList.add(new Student("lisi",24));
        studentList.add(new Student("wangwu",25));

        // 使用方法引用将姓名和年龄拼接成字符串并放到数组中
        String[] nameAgeArray = studentList.stream()
                .map(student -> student.getName() + "-" + student.getAge())
                .toArray(String[]::new);

        // 打印结果
        for (String nameAge : nameAgeArray) {
            System.out.println(nameAge);
        }
    }
}

10、方法引用总结

1.什么是方法引用？
把已经存在的方法拿过来用，当做函数式接口中抽象方法的方法体
2.::是什么符号？
方法引用符
3.方法引用时要注意什么？
- 要使用方法引用的，需要是函数式接口
- 被引用方法必须已经存在
- 被引用方法的形参和返回值需要跟抽象方法保持一致
- 被引用方法的功能要满足当前的需求

3.引用静态方法
类名::静态方法

4.引用对象的实例方法	（可以引用所有类中的成员方法，与【5.】不同）
对象名::成员方法	（引用任意一个类的成员方法，要求形参和返回值要一样）
ths::成员方法	（引用本类的成员方法，只能写在非静态方法中，静态方法可以使用类名::成员方法）
super::成员方法		（引用父类的成员方法，只能写在非静态方法中，静态方法可以使用类名::成员方法）

5.引用类的实例方法
类名::成员方法  （被引用的方法形参是跟抽象方法第二个参数后面的保持一致）
注：不能引用所有类中的成员方法，如果抽象方法的第一个参数是A类型的，只能引用A类中的方法。

6.引用构造方法
类名::new


7.引用数组的构造方法
数据类型[]::new

使用类名引用实例方法的参数对应解释：