lambda表达式
    取代内部类，接口只有一个方法的时候，或者有@FunctionalInterface注解的时候
    @FunctionalInterface是一个标记接口，标志当前接口中只有一个需要实现的函数，修饰的就是函数式接口

    1.         // 内部类
    2.         Runnable runnable = new Runnable() {
    3.             @Override
    4.             public void run() {
    5.                 System.out.println("输出");
    6.             }
    7.         };
    8.         // lambda
    9.         Runnable runnable = () -> {
    10.             System.out.println("输出");
    11.         };
    13.         // 如果实现只有一行代码
    14.          Runnable runnable = () -> 
    15.             System.out.println("输出");

    变量的作用域，和匿名函数是一样的，只能引用final类型的外部变量

    Stream流
    使用场景就是处理集合
    使用Stream流程,
    1.创建Stream数据源.stream()
    2.数据处理转换stream
    3.聚合操作.collect()

    1.        @Data
    2.     public class Student {
    3.         private String name;
    4.         private Integer age;
    5.         private double size;
    6.         private double salary;
    7.     }
    9.     List<Student> studentList = Arrays.asList(
    10.             new Student("a43", 18, 188, 35000),
    11.             new Student("b53", 30, 188, 45000),
    12.             new Student("c66", 26, 188, 55000),
    13.             new Student("d110", 24, 188, 36000),
    14.             new Student("e34", 32, 188, 43000)
    15.     );
    16.     @Test
    17.     public void test6() {
    18.         // 输出["e34","b53","c66","d110"]
    19.         List<String> collect = studentList.stream() // 创建一个Stream流对象
    20.                 .filter(student -> student.getAge() > 20) // 筛选出年龄大于20的学生
    21.                 .sorted(Comparator.comparingInt(Student::getAge).reversed()) // 排序 reversed为降序
    22.                 .map(Student::getName)// 映射，最终只需要输出名字，取出name属性
    23.                 .collect(Collectors.toList());//结果的收集器 创建一个新的list,也可以是set和map
    24.         // 数据转为Map
    25.         // 输出{"b53":{"age":30,"name":"b53","salary":45000,"size":188},"a43":{"age":18,"name":"a43","salary":35000,"size":188},"d110":{"age":24,"name":"d110","salary":36000,"size":188},"c66":{"age":26,"name":"c66","salary":55000,"size":188},"e34":{"age":32,"name":"e34","salary":43000,"size":188}}
    26.         Map<String, Student> collect1 = studentList.stream()
    27.             .collect(Collectors.toMap(Student::getName, Function.identity()));
    29.         // 通过年龄分组
    30.         // 输出{32:[{"age":32,"name":"e34","salary":43000,"size":188}],18:[{"age":18,"name":"a43","salary":35000,"size":188}],24:[{"age":24,"name":"d110","salary":36000,"size":188}],26:[{"age":26,"name":"c66","salary":55000,"size":188}],30:[{"age":30,"name":"b53","salary":45000,"size":188}]}
    31.         Map<Integer, List<Student>> collect1 = studentList.stream()
    32.             .collect(Collectors.groupingBy(Student::getAge));
    33.     }
    37.     //挨个操作，可以做累加
    38.     @Test
    39.     public void test6() {
    40.         List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
    41.         Optional<Integer> reduce = list.stream().reduce((i, j) -> {
    42.             i += j;
    43.             return i;
    44.         });
    45.         // 15
    46.         System.out.println(reduce.get());
    48.         List<String> strings = Arrays.asList("一", "二", "三", "四", "五");
    49.         Optional<String> reduce1 = strings.stream().reduce((i, j) -> {
    50.             i += j;
    51.             return i;
    52.         });
    53.         // 一二三四五
    54.         System.out.println(reduce1.get());
    55.     }