Lambda表达式
1 什么是lambda表达式
本质是一个“语法糖”，由编译器帮你转换常规的代码，使之变成可读性更高，更为简洁。

2 优势
简洁
可读性高

3 语法
(parameters) -> expression 或者 (parameters) ->{ statements; }
说明：
parameters代表后边expression表达式的入参，expression代表表达式
示例：

                 String[] atp =  {“white”,"blue","black"}   ;                
                 List players = Arrays.asList(atp);
                  // 以前的循环方式 
                 for (String player : players) { 
                             System.out.print(player + "; "); 
                 } 
                 players.forEach((player) -> System.out.print(player + "; ")); 

4 应用场景
4.1 匿名内部类

             new Thread(new Runnable() {

                @Override 

                    public void run() { 

                         System.out.println("Hello world !"); 

                    } 

             }).start(); 
             //lambda表达式写法
            new Thread(() -> System.out.println("Hello world !")).start();

Stream流式处理
1 什么是stream流式编程
Stream（流）是一个来自数据源的元素队列并支持聚合操作。
流：
数据源：数据来源
聚合操作：类似于sql的一系列操作，比如map，reduce，filter等等
2 生成stream对象的方法
1 Stream接口的静态工厂方法
2 Collection接口和数组的默认方法
2.1 静态工厂方法：

                // of方法
                Stream<Integer> str = Stream.of(1,2,3); 

               // generate方法
                Stream generateA = Stream.generate(new Supplier() {
                     @Override
                      public Double get() {
                            return java.lang.Math.random();
                     }
               });
              Stream generateB = Stream.generate(()-> java.lang.Math.random());
              Stream generateC = Stream.generate(java.lang.Math::random);

              /*   iterate方法
              iterate方法，其返回的也是一个无限长度的Stream，与generate方法不同的是，其是通过
              函数f迭代对给指定的元素种子而产生无限连续有序Stream，其中包含的元素可以认为
             是：seed，f(seed),f(f(seed))无限循环*/                 
              Stream.iterate(1, item -> item + 1).limit(10).forEach(System.out::println);

···

2.2 Collection类接口和数组默认的方法

···

              Stream s1 = Arrays.asList("a","b","c").stream();
              Stream s2 = Arrays.asList("a","b","c").parallelStream();

2.3聚合操作
2.3.1distinct方法（去重）

                   List list = Stream.of("a","b","c","b").distinct().collect(Collectors.toList());

2.3.2 filter操作（过滤）
filter传入的Lambda表达式必须是Predicate实例，参数可以为任意类型，而其返回值必
须是boolean类型。

                  List list =                                                                                                                                                                                 
                     Stream.of("a","b","c","b").filter(s>s.equals("b')).collect(Collectors.toList());

2.3.3 map操作
方法根据传入的mapper函数对元素进行一对一映射, 即数据源中的每一个元素都会在结
果中被替换(映射)为mapper函数的返回值

                   List list = 
                     Stream.of('a','b','c').map( s -> s.hashCode()).collect(Collectors.toList());

2.3.4 sorted函数
主要涉及到3种

                       list.stream().sorted()  ；   //对list中的元素按照正序排序
                       list.stream().sorted(Comparator.reverseOrder());     //倒叙排序
                       list.stream().sorted(Comparator.comparing(Student::getAge))；    //如果list中是对象  

2.3.5 reduce 函数
语法：reduce(T identity, BinaryOperator accumulator)

                       //计算所有人的年龄之和
                       int sum = personList.parallelStream().mapToInt(Person::getAge).reduce(0, (x, y) -> 
                x + y);

2.3.6 limit/skip
limit表示取出前n条数据，skip表示过滤掉前n条数据

 public static void testLimitAndSkip() {
    List<Person> persons = new ArrayList();
    for (int i = 1; i <= 10000; i++) {
        Person person = new Person(i, "name" + i);
        persons.add(person);
    }
    List<String> personList2 = persons.stream().
            map(Person::getName).limit(10).skip(3).collect(Collectors.toList());
    System.out.println(personList2);
}
private static class Person {
    public int no;
    private String name;
    public Person (int no, String name) {
        this.no = no;
        this.name = name;
    }
    public String getName() {
        System.out.println(name);
        return name;
    }
}