什么是流

Stream 不是集合元素，它不是数据结构并不保存数据，它更像一个高级版本的 Iterator。原始版本的 Iterator，用户只能显式地一个一个遍历元素并对其执行某些操作；高级版本的 Stream，用户只要给出需要对其包含的元素执行什么操作，比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等，Stream 会隐式地在内部进行遍历，做出相应的数据转换。

Stream 就如同一个迭代器（Iterator），单向，不可往复，数据只能遍历一次，遍历过一次后即用尽了，就好比流水从面前流过，一去不复返。

而和迭代器又不同的是，Stream 可以并行化操作，迭代器只能命令式地、串行化操作。顾名思义，当使用串行方式去遍历时，每个 item 读完后再读下一个 item。而使用并行去遍历时，数据会被分成多个段，其中每一个都在不同的线程中处理，然后将结果一起输出。

【注意】

• Stream 自己不会存储元素
• Stream不会改变源对象。相反，他们会返回一个持有新结果的Stream
• Stream操作是延迟操作，这意味着他们会等到需要结果的时候才执行

流的构成

当我们使用一个流的时候，通常包括三个基本步骤：

获取一个数据源（source）→ 数据转换→执行操作获取想要的结果，每次转换原有 Stream 对象不改变，返回一个新的 Stream 对象（可以有多次转换），这就允许对其操作可以像链条一样排列，变成一个管道，如下图所示。

【创建Stream】

public class TestStreamAPI1 {

    /**
     * 创建Stream
     */
    @Test
    public void test1(){
        //1. 可以通过Collection系列集合提供的stream()或parallelStream()
        //stream()：获取串行流   parallelStream()：获取并行流
        List<String> list = new ArrayList<>();
        Stream<String> stream1 = list.stream();

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

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

        //4. 创建无限流
        //迭代
        Stream<Integer> stream4 = Stream.iterate(0,(x)->x+2); //第一个参数是起始值，第二个参数是操作
        //stream4.forEach(System.out::print);   从0开始做x+2的操作，然后无限输出
        stream4.limit(10).forEach(System.out::print);  //只输出10个结果

        //生成
        Stream.generate(()->Math.random())
                       .limit(5)  //限制只产生5个随机数
                       .forEach(System.out::print);
    }
}

【Stream的中间操作】

准备操作

public class Employee {
    public String name;
    public Integer age;
    public Double salary;
    public Status status;

    public Employee(String name, Integer age, Double salary, Status status) {
        this.name = name;
        this.age = age;
        this.salary = salary;
        this.status = status;
    }

    @Override
    public boolean equals(Object o) {
        ...
        //自动生成的equals方法，太长了此处省略
    }

    @Override
    public int hashCode() {
        int result = getName() != null ? getName().hashCode() : 0;
        result = 31 * result + (getAge() != null ? getAge().hashCode() : 0);
        result = 31 * result + (getSalary() != null ? getSalary().hashCode() : 0);
        return result;
    }

   public enum Status{
        FREE,
        BUSY,
        VOCATION;
    }
   // 此处省略getter和setter
}

（1）筛选与切片

• filter —— 接收lambda，从中筛选某些元素
• limit(N) —— 截断流，使其元素不超过给定量
• skip(N) —— 跳过元素，返回一个扔掉了前N个元素的流。若流中的元素不足N个，则返回一个空流，和limit(N)互补
• distinct —— 筛选，通过该流所生成的元素的 hashCode() 和 equals() 去除重复元素

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY),
            new Employee("田七",45,8888.88, Employee.Status.BUSY),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test1(){

        // 中间操作：不会执行任何处理
        Stream s = employees.stream()
                .filter((e) -> { //参数为Predicate
                    System.out.print("Stream API的中间操作");
                    return e.getAge() >35;
                } );

        // 终止操作：只有执行终止操作，所有的中间操作才会一次性全部执行
        s.forEach(System.out::println);
    }

    @Test
    public void test2(){
        //取前两个结果
        employees.stream()
                 .filter(e->e.getSalary()>5000)
                 .limit(10)
                 .forEach(System.out::println);
    }

    @Test
    public void test3(){
        //跳过前两个结果
        employees.stream()
                .filter(e->e.getSalary()>5000)
                .skip(2)
                .forEach(System.out::println);
    }

    @Test
    public void test4(){
        //要想去除重复元素，Employee必须重写hashCode和equals方法
        employees.stream()
                .filter(e->e.getSalary()>5000)
                .skip(2)
                .distinct()
                .forEach(System.out::println);
    }
}

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”。

此外，迭代操作是由Stream API给我们完成的，称为内部迭代，不用我们自己手动迭代。

（2）映射

• map：接收Lambda，将元素转换成其他形式或提取信息，接受一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。
• flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流。

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test5(){

        List<String> list = Arrays.asList("aaa","bbb","ccc","eee","ddd");
        list.stream()
            .map((str)->str.toUpperCase())
            .forEach(System.out::println);

        System.out.println("---------------------");

        employees.stream()
                 .map(Employee::getName)
                 .forEach(System.out::println);

        System.out.println("---------------------");

        //map返回一个Stream,filterCharacter函数返回的也是一个 Stream
        //filterCharacter函数功能就是：提取出来一个数如aaa，转换成流然后返回
        Stream<Stream<Character>> stream = list.stream()
                .map(TestStreamAPI1::filterCharacter); //{{a,a,a} {b,b,b},...}

        stream.forEach((sm)->{
            sm.forEach(System.out::println);
        });

        System.out.println("---------------------");

        //使用flatMap简化上面的操作
        Stream<Character> sm = list.stream()
                .flatMap(TestStreamAPI1::filterCharacter); //{a,a,a,b,b,b,...}
        sm.forEach(System.out::println);
    }

    public static Stream<Character> filterCharacter(String str){
        List<Character> list = new ArrayList<>();

        //将字符串变成字符数组
        for(Character ch:str.toCharArray()){
            list.add(ch);
        }

        return list.stream();
    }
}

从上面的代码中我们可以知道，Map是把整个集合添加到当前集合中，flatMap是把集合中每一个元素添加到当前集合中：

（3）排序

• sort()：自然排序（Comparable），就是按照String写好的方法排序
• sorted(Comparator com)：定制排序（Comparator）

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test6(){
        List<String> list = Arrays.asList("aaa","bbb","ccc","eee","ddd");

        list.stream()
            .sorted()
            .forEach(System.out::println);

        System.out.println("---------------------");

        employees.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的终止操作】

（1）查找与匹配

• allMatch：检查是否匹配所有元素
• anyMatch：检查是否至少匹配一个元素
• noneMatch：检查是否没有匹配所有元素
• findFirst：返回第一个元素
• findAny：返回流中元素的总个数
• count：返回流中元素的总个数
• max：返回流中最大值
• min：返回流中最小值

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test1(){
        //判断是否所有的employee都是Status.BUSY状态
        boolean b1 = employees.stream()
                .allMatch(e->e.getStatus().equals(Employee.Status.BUSY));
        System.out.print(b1);

        //是否至少有一个employee是Status.BUSY状态
        boolean b2 = employees.stream()
                .anyMatch(e->e.getStatus().equals(Employee.Status.BUSY));
        System.out.print(b2);

        //是不是没有employee是Status.BUSY状态
        boolean b3 = employees.stream()
                .noneMatch(e->e.getStatus().equals(Employee.Status.BUSY));
        System.out.print(b3);

        //获取工资最高的employee
        Optional<Employee> op = employees.stream()
                .sorted((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary()))
                .findFirst();  //结果有可能为空，所以封装到Optional中去

        System.out.print(op.get());

        //找空闲状态的员工
        Optional<Employee> op1 = employees.stream()
                .filter(e->e.getStatus().equals(Employee.Status.BUSY))
                .findAny();
        System.out.print(op1.get());   //因为是串行流，按顺序找的，所以获取到的一直是张三

        Optional<Employee> op2 = employees.parallelStream()
                .filter(e->e.getStatus().equals(Employee.Status.BUSY))
                .findAny();
        System.out.print(op1.get());   //并行流，多个员工同时找，所以获取到的是张三或者赵六

    }

    @Test
    public void test2(){
        Long count = employees.stream().count();

        //提取工资最高的员工
        Optional<Employee> op1 = employees.stream()
                .max((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary()));
        System.out.print(op1.get());

        //获取公司中最小的工资是多少
        Optional<Double> op2 = employees.stream()
                .map(Employee::getSalary)  //先把所有人的工资提取出来
                .min(Double::compare);
        System.out.print(op1.get());

    }

}

（2）规约

• reduce(T identify,BinaryOperator) /：可以将流中元素反复结合起来，得到一个值，返回T。T identify为起始值，BinaryOperator为二元运算。
• reduce(BinaryOperator)：可以将流中元素反复结合起来，得到一个值，返回Optional<T>。

map和reduce的连接通常称为map-reduce模式，用于大数据。

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );

    @Test
    public void test2(){
        Long count = employees.stream().count();

        //提取工资最高的员工
        Optional<Employee> op1 = employees.stream()
                .max((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary()));
        System.out.print(op1.get());

        //获取公司中最小的工资是多少
        Optional<Double> op2 = employees.stream()
                .map(Employee::getSalary)  //先把所有人的工资提取出来
                .min(Double::compare);
        System.out.print(op1.get());

    }

    @Test
    public void test3(){
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);

        //reduce一开始把0作为x，list中第一个元素作为y，实现x+y=1,然后再把1作为x，2作为y...，就这样将元素反复结合起来
        Integer sum = list.stream()
                .reduce(0,(x,y)->x+y);
        System.out.print(sum);

        System.out.print("--------------------------");

        //计算公司工资总和
        Optional<Double> op1 = employees.stream()
                .map(Employee::getSalary)  //先把所有人的工资提取出来
                .reduce(Double::sum);
        System.out.print(op1.get());
    }

}

（3）收集

• collect(Collector c)：将流转换为其他形式，接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。

Collector接口中的方法的实现决定了如何对流执行收集操作（如收集到List、Set、Map）。但是Collector实用类提供了很多静态方法，可以方便地创建常见收集器实例。

public class TestStreamAPI1 {

    List<Employee> employees = Arrays.asList(
            new Employee("张三",18,9999.99, Employee.Status.FREE),
            new Employee("李四",58,5555.55, Employee.Status.BUSY),
            new Employee("王五",26,6666.66, Employee.Status.VOCATION),
            new Employee("赵六",36,7777.77, Employee.Status.FREE),
            new Employee("田七",45,8888.88, Employee.Status.BUSY)
    );


    @Test
    public void test4(){
        //将公司当前所有人的名字收集到一个list中去
        List<String> list = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toList());
        list.forEach(System.out::println);

        System.out.println("----------------------");

        //将公司当前所有人的名字收集到一个set中去，可以避免重复值
        Set<String> set = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toSet());
        set.forEach(System.out::println);

        System.out.println("----------------------");

        //将公司当前所有人的名字收集到一个自定义的特殊集合中去，这里为HashSet
        HashSet<String> sh = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.toCollection(HashSet::new));
        sh.forEach(System.out::println);
    }

    @Test
    public void test5(){
        //收集员工总数
        Long count = employees.stream()
                .collect(Collectors.counting());
        System.out.println(count);
        System.out.println("----------------------");

        //平均数
        Double avg = employees.stream()
                .collect(Collectors.averagingDouble(Employee::getSalary));
        System.out.println(avg);
        System.out.println("----------------------");

        //工资总和
        Double sum = employees.stream()
                .collect(Collectors.summingDouble(Employee::getSalary));
        System.out.println(sum);
        System.out.println("----------------------");

        //最大值，得到工资最高的employee
        Optional<Employee> max = employees.stream()
                .collect(Collectors.maxBy((e1,e2)->Double.compare(e1.getSalary(),e2.getSalary())));
        System.out.println(max.get());

        //最小值
        Optional<Double> min = employees.stream()
                .map(Employee::getSalary)
                .collect(Collectors.minBy(Double::compare));
        System.out.println(min.get());
    }

    //分组
    @Test
    public void test6(){
        Map<Employee.Status,List<Employee>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus));
        System.out.println(map);
    }
}

    //多级分组
    @Test
    public void test7(){
        //先按状态分组，再按照年龄段分组
        Map<Employee.Status,Map<String,List<Employee>>> map = employees.stream()
                .collect(Collectors.groupingBy(Employee::getStatus,Collectors.groupingBy(e->{
                    if(e.getAge() <= 35){
                        return "青年";
                    }else if(e.getAge() <= 50){
                        return "中年";
                    }else{
                        return "老年";
                    }
                })));
        System.out.println(map);
    }

   //分区：满足条件的一个区，不满足条件的一个区
    @Test
    public void test8(){
        //先按状态分组，再按照年龄段分组
        Map<Boolean,List<Employee>> map = employees.stream()
                .collect(Collectors.partitioningBy((e)->e.getSalary()>8000));
        System.out.println(map);
    }

    @Test
    public void test8(){
        DoubleSummaryStatistics ds = employees.stream()
                .collect(Collectors.summarizingDouble(Employee::getSalary));
        System.out.println(ds.getAverage());
        System.out.println(ds.getMax());
        System.out.println(ds.getCount());
    }

    @Test
    public void test8(){
        //把所有名字变成字符串
        String str = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining());
        System.out.println(str); //"张三李四王五赵六田七"

        String str1 = employees.stream()
                .map(Employee::getName)
                .collect(Collectors.joining(",","===","==="));
        System.out.println(str1); //"===张三,李四,王五,赵六,田七==="
    }