前言：JDK1.8新特性知识点

红黑树 – 速度更快
Lambda表达式 – 代码更少
函数式接口
方法引用和构造器调用
Stream API – 强大的Stream API
接口中的默认方法和静态方法
新时间日期API

五、Stream API

概述：

是用函数式编程方式在集合类上进行复杂操作的工具，更像一个高级版本的 Iterator；
原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作，
高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，
Stream 会隐式地在内部进行遍历，做出相应的数据转换，
而和迭代器又不同的是，Stream 可以并行化操作，
借助于 Lambda 表达式，极大的提高编程效率和程序可读性

Stream操作的三个步骤

创建stream
中间操作（过滤、map）
终止操作

Stream的创建：

    // 1，校验通过Collection 系列集合提供的stream()或者paralleStream()
    List<String> list = new ArrayList<>();
    Strean<String> stream1 = list.stream();

    // 2.通过Arrays的静态方法stream()获取数组流
    String[] str = new String[10];
    Stream<String> stream2 = Arrays.stream(str);

    // 3.通过Stream类中的静态方法of
    Stream<String> stream3 = Stream.of("aa","bb","cc");

    // 4.创建无限流
    // 迭代
    Stream<Integer> stream4 = Stream.iterate(0,(x) -> x+2);

    //生成
    Stream.generate(() ->Math.random());

Stream的中间操作：

  /**
   * 筛选 过滤  去重
   */
  emps.stream()
          .filter(e -> e.getAge() > 10)
          .limit(4)
          .skip(4)
          // 需要流中的元素重写hashCode和equals方法
          .distinct()
          .forEach(System.out::println);


  /**
   *  生成新的流 通过map映射
   */
  emps.stream()
          .map((e) -> e.getAge())
          .forEach(System.out::println);


  /**
   *  自然排序  定制排序
   */
  emps.stream()
          .sorted((e1 ,e2) -> {
              if (e1.getAge().equals(e2.getAge())){
                  return e1.getName().compareTo(e2.getName());
              } else{
                  return e1.getAge().compareTo(e2.getAge());
              }
          })
          .forEach(System.out::println);

Stream的终止操作：

        /**
         *      查找和匹配:
         *          allMatch-检查是否匹配所有元素
         *          anyMatch-检查是否至少匹配一个元素
         *          noneMatch-检查是否没有匹配所有元素
         *          findFirst-返回第一个元素
         *          findAny-返回当前流中的任意元素
         *          count-返回流中元素的总个数
         *          max-返回流中最大值
         *          min-返回流中最小值
         */

        /**
         *  检查是否匹配元素
         */
        boolean b1 = emps.stream()
                .allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b1);

        boolean b2 = emps.stream()
                .anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b2);

        boolean b3 = emps.stream()
                .noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
        System.out.println(b3);

        Optional<Employee> opt = emps.stream()
                .findFirst();
        System.out.println(opt.get());

        // 并行流
        Optional<Employee> opt2 = emps.parallelStream()
                .findAny();
        System.out.println(opt2.get());

        long count = emps.stream()
                .count();
        System.out.println(count);

        Optional<Employee> max = emps.stream()
                .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(max.get());

        Optional<Employee> min = emps.stream()
                .min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(min.get());

还有功能比较强大的两个终止操作 reduce和collect

reduce操作：

reduce:(T identity,BinaryOperator)/reduce(BinaryOperator)-可以将流中元素反复结合起来，得到一个值

      /**
        *  reduce ：规约操作
        */
       List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
       Integer count2 = list.stream()
               .reduce(0, (x, y) -> x + y);
       System.out.println(count2);

       Optional<Double> sum = emps.stream()
               .map(Employee::getSalary)
               .reduce(Double::sum);
       System.out.println(sum);

collect操作：

Collect-将流转换为其他形式，接收一个Collection接口的实现，用于给Stream中元素做汇总的方法

        /**
         *  collect：收集操作
         */

        List<Integer> ageList = emps.stream()
                .map(Employee::getAge)
                .collect(Collectors.toList());
        ageList.stream().forEach(System.out::println);

承接上篇博客，JDK1.8新特性(一)，链接：
https://blog.csdn.net/u013068377/article/details/82861655

JDK1.8新特性(二)