Java中的Lambda表达式的使用（详解）

一、概述

        Lambda表达式 --> 函数式编程（函数编程思想）

        面向对象编程思想：

                强调的是【对象】，必须通过对象的形式来做一些事情，一般情况下会比较复杂。

                例如：多线程执行任务，需要创建对象，对象需要实现接口Runnable，我们想自己完成，需要将run方法中的代码传递给线程对象，这么麻烦？直接执行不久好了吗？

        函数编程思想：

                函数需要得有输入量、输出量，使用输入量计算得到输出量，【拿什么东西做什么事】

                就是为了尽量忽略对象的复杂用法---强调做什么，而不是以什么实行做，

                同样执行线程任务，使用函数编程思想，可以直接通过传递一段代码给线程对象执行，不需要创建任务对象。

                总之就一句话，函数编程思想可以通过一段代码完成面向对象想要做的代码量

二、Lambda表达式的格式

        1.标准格式：

                （参数列表） -> {代码}

        2.格式说明：

                - 小括内的语法与传统方法参数列表一致，没有参数就留空，有多个参数就用逗号分隔

                -  【->】  是新引入的语法格式，代表指向动作

                - 大括号内的语法与传统方法体要求一致

        3.案例说明

                第一个线程案例

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run () {
                System.out.println("线程需要执行的任务代码1");
            }
        });
        thread1.start();

        // Lambda表达式
        Thread t2 = new Thread(()->{
            System.out.println("线程需要执行的任务代码2");
        });
        t2.start();

                第二个比较器案例

        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,11,22,33,44,55);
        System.out.println("排序之前的集合：" + list);
        
        // 比较器的正常书写格式
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare (Integer o1, Integer o2) {
                return o2-o1;
            }
        });

        // Lambda表达式
        Collections.sort(list,(Integer o1, Integer o2)->{return o2-o1;});
        System.out.println("排序之后的集合：" + list);

三、表达式格式解析

        Lambda表达式格式：（）->{}

                1.小括号中书写的内容和接口中的抽象方法的参数列表一致

                2.大括号中书写的内容和实现接口中的抽象方法体一致

                3.箭头是固定的

四、Lambda表达式的使用条件

        首先，都是接口；    其次，接口中有且只有一个接口，才可以使用lambda表达式

        1.接口中只有一个抽象方法的接口，叫做函数式接口

        2.如果是函数式接口，那么就可以用@FunctionalInterface注解标识

 上面这个是Thread线程的底层，下面的是Collections的底层

        思考（扩展）：

         Collections接口中有且只有一个抽象方法compareTo（），为什么Java底层没有给它@FunctionalInterface注解标识？（底层代码较多，截图不便，放心，我替你们看过了）
        因为：lambda表达式属于  锦上添花  的功能，每个类都有各自的功能或作用，而Comparable接口目前学习到的主要是为了给自定义类实现比较器方法的，@FunctionalInterface注解标识的作用主要是为了给编译器看，给编译器提供信息的，不管有没有这个注解，只要满足函数式的要求，那么它就是一个函数式接口

五、Lambda表达式的省略格式

        Lambda是挺简便的，往下看

        Lambda表达式的省略格式：

                1.小括号中的形参类型可以省略

                2.如果小括号中只有一个参数的话，那么小括号可以省略

                3.如果大括号中只有一条语句，那么大括号、分号、return可以一起 省略

        代码案例：

                1.第一个还是线程案例

      new Thread(()-> System.out.println("省略")).start();

                就这一行，就创建好了一个线程，并且可以将它顺利启动。

                如果觉得不够明了的话，看第二个案例

                2.第二个比较器的案例

        public static void main (String[] args) {
      
        // 比较器案例
        ArrayList<Integer> list = new ArrayList<>();
            list.add(11);
            list.add(22);
            list.add(33);
            list.add(44);
            System.out.println("排序前：" + list);

            // 比较器常规写法
            Collections.sort(list, new Comparator<Integer>() {
                @Override
                public int compare (Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });

            // Lambda表达式
            Collections.sort(list,(o1,o2)->o2-o1);
            System.out.println("排序后：" + list);
        }

        

六、表达式的表现形式

        1.变量的形式：变量的类型为函数式接口，就么可以复制一个Lambda表达式【不常用】

        // 变量的形式
        Runnable r = ()->{
            System.out.println("任务代码");
        };
        // 函数式接口类型的变量
        Thread t = new Thread(r);

        2.参数的形式：方法的形参类型为函数式接口，就可以传入一个Lambda表达式【常用】

        // 变量的形式-比较器
        Comparator<Integer> comparable = (o1, o2)->{return o2 - o1;};
        // 创建集合
        ArrayList<Integer> list = new ArrayList<>();
        // 存入数据
        Collections.addAll(list,11,22,33,44,55);

        // 将函数式接口类型  的 形参类型，传给Collections
        Collections.sort(list,comparable);

        3.返回值的形式：方法的返回值类型为函数式接口，就可以返回一个Lambda表达式【常用】

        // 定义一个方法
        public static Comparator<Integer> getComparator(){
            return (Integer o1,Integer o2)->{return  o2-o1;};
        }
        
        public static void main (String[] args) {
            // 返回值形式
            Collections.sort(list,getComparator());
        }