Lambda表达式

1.面向对象编程思想：

        强调的是【对象】。必须通过对象的形式来做一些事情，一般情况下会比较复杂，多线程执行任务，需要创建对象，对象需要实现接口Runnable

2.函数编程思想：

       函数需要的有输入量，输出量，使用输入量计算得到输出量，“拿什么东西做什么事”
        就是为了尽量忽略对象的复杂用法---强调做什么，而不是以什么形式做，同样线程执行任务，使用函数编程思想，可以直接通过传递一段代码给线程对象执行，不需要创建任务对象。
                函数编程思想可以通过一段代码完成 面向对象思想 需要做的代码量

3.比如多线程执行：

  - 实现Runnable接口的方式创建线程执行任务
      1.创建实现类，实现Runnable接口
      2.在实现类中，重写run（）方法，把任务代码放入run（）方法中
      3.创建实现类对象
      4.创建Thread线程对象，传入实现类对象
      5.使用线程对象调用start（）方法，启动并执行线程
  -->  我们发现，创建并启动一个线程需要五个步骤，一步都不能少，创建实现类是为了得到线程的任务，比较复杂

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("实现的方法创建线程的任务   执行了...");
    }
}



public class Tests {
    public static void main(String[] args) {
        // 实现类对象
        MyRunnable mr = new MyRunnable();

        // 线程对象
        Thread  t = new Thread(mr);

        // 启动线程
        t.start();
    }
}

上述线程执行步骤优化后也较为复杂，所有我们可以使用lambda表达式
      - lambda表达式创建线程执行任务
          - 以上两种方式都是通过Runnable接口的实现类对象，来传入线程需要执行的任务（面向对象编程）
          - 思考：是否能不通过Runnable接口的实现类对象传入任务，而是直接把任务传给线程
      - lambda表达式是  JDK1.8引入的新语法，用来代替【面向某种接口】编程的情况

public class Tests {
    public static void main(String[] args) {
        // lambda表达式创建线程执行任务
        new Thread(()->{
            System.out.println("匿名内部类的方式创建线程的任务  执行了");
        }).start();

        new Thread(()->System.out.println("匿名内部类的方式创建线程的任务  执行了")).start();
        //lambda 表达式的作用就是简化代码。省略了面向对象中 类和方法的书写
    }
}

4.Lambda表达式的标准格式：

- 标准格式： （参数列表）->{代码}
- 格式说明：
         - 小括号的语法与传统方法参数列表一致，没有参数就留空；有多个参数就是用逗号分隔
         - 【->】是新引入的语法格式，代表指向动作
         - 大括号内的语法与传统方法体要求一致

public class Tests {
    public static void main(String[] args) {
// 第一种线程案例：
Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程需要执行的任务代码1...");
    }
});
t1.start();
Thread t2 = new Thread(()->{System.out.println("线程需要执行的任务代码1...");});
t2.start();
// 第二种比较器案例：
List<Integer> list = new ArrayList<>();
Collections.addAll(list,27,11,22,33,44,55,66,77,88,99);
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注解标识
思考一： Java函数式接口，为什么Comparator接口中有两个抽象方法compare和equals，Comparator还是一个函数式接口呢？
        @FunctionalInterface 的java doc 中有解释：
                1.一个函数式接口有且只有一个抽象方法
                2.默认方法不是抽象方法，因为他们已经实现了
                3.重写了超类Object类中任意一个public方法的方法并不算接口中的抽象方法
        所以，虽然Comparator接口中有两个抽象方法，但equal方法并不算入接口中的抽象方法，所以Comparator接口还是满足函数式接口的要求

思考二：Comparable接口里面也只有一个抽象方法compareTo（），但为什么Java底层代码没有给他@FunctionalInterface  标识呢
        lambda表达式属于 锦上添花的 功能，每个类都有各自的功能或作用，而Comparable接口目前学习到的主要是为了给对自定义类实现比较器方法的
@FunctionalInterface 标识的作用主要是为了给编译器看，给编译器提供信息的，不管有没有这个标识注解，只要满足函数式接口的要求，那么他就是一个函数式接口

5.Lambda表达式省略模式：

        1.小括号中的形参类型可以省略
        2.如果小括号中只有一个参数的话，那么小括号可以省略
        3.如果大括号只有一条语句，那么大括号、分号、return可以 一起 省略

public class Tests {

    public static void main(String[] args) {
        // 线程案例
        new Thread(()-> System.out.println("省略")).start();

        //比较器案例
        ArrayList<Integer> list = new ArrayList<>();
        list.add(11);
        list.add(22);
        list.add(33);
        list.add(44);
        list.add(55);
        System.out.println("排序前："+list);
        Collections.sort(list,(o1,o2)->o2-o1);
        System.out.println("排序后："+list);

        // 普通调用
        showA(new A() {
            @Override
            public void methodA(int num) {
                System.out.println("自定义函数式接口");
            }
        });

        // 函数式调用
        showA((int num) -> { System.out.println("自定义函数式接口标准格式"); });
        showA(num-> System.out.println("自定义函数式接口省略格式"));

        // 普通调用
        int num1 = showB(new B() {
            @Override
            public int methodB(int num) {
                return 10;
            }
        });


        // 函数式调用
        int num2 = showB((int num) -> { return 10; });
        int num3 = showB(num->10);
        System.out.println(num2+num3);


    }
    public static void showA(A a){
        a.methodA(10);
    }

    public static int showB(B b){
        return b.methodB(10);
    }

}
@FunctionalInterface
interface A{
    void methodA(int num);
}


@FunctionalInterface
interface B{
    int methodB(int num);
}

6.Lambda表达式的表示形式：

        1.变量的形式：变量的类型为函数式接口，那么可以赋值一个Lambda表达式  【不常用】
        2.参数的形式：方法的形参类型为函数式接口，那么可以传入一个Lambda表达式    【常用】
        3.返回值的形式：方法的返回值类型为函数式接口，那么可以返回一个Lambda表达式  【常用】

public class Tests {

    public static void main(String[] args) {
        // 变量的形式-任务线程
        Runnable r = () -> {
            System.out.println("任务代码");
        };

        Thread t = new Thread(r);
        t.start();
        // 变量的形式-比较器
        Comparator<Integer> comparator = (o1,o2)->{return o2-o1;};
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 11, 22, 33, 44, 55);
        Collections.sort(list, comparator);
        System.out.println(list);

        // 参数形式
        new Thread(()-> System.out.println("省略")).start();
        Collections.sort(list,(o1,o2)->o2-o1);

        // 返回值形式
        Collections.sort(list,getComparator());
    }
    public static Comparator<Integer> getComparator(){
        return (Integer o1,Integer o2)->{return  o2-o1;};
    }
}