Java：Lambda表达式、方法引用

学习方法引用之前先学匿名内部类和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))