Stream流

1.Stream 概述

Java 8 是一个非常成功的版本，这个版本新增的Stream，配合同版本出现的 Lambda ，给我们操作集合（Collection）提供了极大的便利。

1.什么是Stream？

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

流，是一系列数据项，它不是一种数据结构。
流可以进行相关的算法和计算，只是它并没有显式地表现，而是在内部进行隐式地操作

2.流的种类

Stream 可以有数组或集合创建，对流的操作分为两种

1. 中间操作每次返回一个新的流，可以有多个
2. 终端端操作，每个流只能进行一次总端操作，总端操作结束后结束后流就无法使用， 终端操作会产生一个新的集合或值。

3. Stream有几个特性：

1. stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果。
2. stream不会改变数据源，通常情况下会产生一个新的集合或一个值。
3. stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。
4. 流，解决了两个问题，1.直接实现你”想要什么”，2.可以进行并行处理。

4.Stream的操作三步骤

1. 创建stream：一个数据源（如数组，集合），获取一个流
2. 中间操作：一个中间操作链，对数据源的数据进行处理
3. 终止操作：一旦执行终止操作，就执行了中间的操作链，并产生结果，之后不会在被使用

2.Stream 的创建

1.方式一

Java8 中的 Collection 接口被扩展，提供了两个获取流 的方法：

1. default Stream stream() : 返回一个顺序流
2. default Stream parallelStream() : 返回一个并行流

    /*
    *方式一
    * */
    @Test
    public void show1(){
        //创建集合
        List<String> strings = Arrays.asList("oo", "ppp", "uuu");
          //获取顺序流
        Stream<String> stream = strings.stream();
        //获取并行流
        Stream<String> stream1 = strings.parallelStream();

    }

2.方式二

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：

1. static Stream stream(T[] array): 返回一个流

重载的形式：能够处理对应基本类型的数组

• public static IntStream stream(int[] array)
• public static LongStream stream(long[] array)
• public static DoubleStream stream(double[] array)

    //方式二
    @Test
    public void show3(){
    //创建一数组
        int[] array={1,2,3,4,5,6,8};
        //获取Stream流
        IntStream stream = Arrays.stream(array);
    }

3.方式三

可以调用Stream类静态方法 of(), 通过显示值创建一个 流。它可以接收任意数量的参数。

1. public static Stream of(T… values) : 返回一个流

    /*
    * 方式三
    * */
    @Test
    public void show4(){
        //获取Stream流
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
    }

4.顺序流和并行流的区别

stream和parallelStream的简单区分： stream是顺序流，由主线程按顺序对流执行操作，而parallelStream是并行流，内部以多线程并行执行的方式对流进行操作，但前提是流中的数据处理没有顺序要求。例如筛选集合中的奇数，两者的处理不同之处：

如果流中的数据量足够大，并行流可以加快处速度

除了直接创建并行流，还可以通过parallel()把顺序流转换成并行流：

Optional<Integer> findFirst = list.stream().parallel().filter(x->x>6).findFirst();

3.Stream 的使用

1.遍历匹配

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单。

    @Test
    public void show(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        //遍历输出符合条件的元素
        list.stream().filter(o->o>6).forEach( System.out::println);
        System.out.println();
        //匹配第一个
        Optional<Integer> first = list.stream().filter(x -> x > 3).findFirst();
        System.out.println("匹配第一个数据" + first);

        //匹配任意（适用于并行流）
        Optional<Integer> any = list.parallelStream().filter(x -> x > 7).findAny();
        System.out.println("any = " + any);
    }

2.筛选(filter)

筛选，是按照一定的规则校验流中的元素，将符合条件的元素提取到新的流中的操

案例一：筛选出Integer集合中大于7的元素，并打印出来

    @Test
    public void show1(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        //案例一：筛选出Integer集合中大于7的元素，并打印出来
        list.stream().filter(o->o>7).forEach(System.out::println);

    }

    @Test
    public void show3(){
    //获取数据
        List<Person> list = getList();
        //案例二： 筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集），返回一个新的集合
        List<Person> collect = list.stream().filter(o -> o.getSalary() > 8000).collect(Collectors.toList());
        collect.forEach(o-> System.out.println("o = " + o));
        
    }
    @Test
    public void show4(){
        //获取数据
        List<Person> list = getList();
        //案例三： 筛选员工中工资高于8000的人，并形成新的集合。 形成新集合依赖collect（收集），后文有详细介绍
        List<String> collect = list.stream().filter(o -> o.getSalary() > 8000).map(Person::getName).collect(Collectors.toList());
        //根据名字获取集合
        collect.forEach(o-> System.out.println("按条件根据名字收集" + o));


    }


    public List<Person> getList(){
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900,12, "male", "New York"));
        personList.add(new Person("Jack", 7000,64, "male", "Washington"));
        personList.add(new Person("Lily", 7800,32, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 20,"female", "New York"));
        personList.add(new Person("Owen", 9500, 80,"male", "New York"));
        personList.add(new Person("Alisa", 7900, 60,"female", "New York"));
        return personList;

    }

3.聚合(max/min/count)

max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。

案例一：获取String集合中最长的元素。

    //获取String集合中最长的元素
    @Test
    public void show5(){
        List<String> list = Arrays.asList("asd", "adasdasdasx", "dasdfwedas", "dewdDSWDXASD", "AXASDSADASXAS");
        Optional<String> max = list.stream().max(Comparator.comparing(String::length));
        System.out.println("max = " + max);

    }

案例二：获取Integer集合中的最大值

    //案例二：获取Integer集合中的最大值

    @Test
    public void show6(){
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        //自然排序
        Optional<Integer> max = list.stream().max(Integer::compareTo);
        //自定义排序
        Optional<Integer> max1 = list.stream().max((o1, o2) -> o1.compareTo(o2));
        System.out.println("max = " + max);
        System.out.println("max1 = " + max1);
    }

案例三：获取员工工资最高的人。

    @Test
    public void show7(){
        //获取数据
        List<Person> list = getList();
   //获取员工工资最大值
        Optional<Person> max = list.stream().max(Comparator.comparingInt(Person::getSalary));
        System.out.println("获取员工的最大工资" + max.get().getSalary());
    }

案例四：计算Integer集合中大于6的元素的个数。

    @Test
    public void show8(){

        //计算Integer里面大于3的个数
        List<Integer> list = Arrays.asList(1, 4, 5, 8, 2, 6, 8, 4, 9);

        long count = list.stream().filter(o -> o > 6).count();
        System.out.println("count = " + count);

    }

4.映射(map/flaMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

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

案例一：英文字符串数组的元素全部改为大写。整数数组每个元素+3。

    @Test
    public void show9(){
        List<String> list = Arrays.asList("dadweads", "cwedada", "FDSXAS", "cdawdxasdas");
        List<String> collect = list.stream().map(String::toUpperCase).collect(Collectors.toList());

        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 4, 8, 9);
        List<Integer> collect1 = list1.stream().map(o -> o + 3).collect(Collectors.toList());
        System.out.println("每个元素大写" + collect);
        System.out.println("每个元素+3" + collect1);


    }

案例二：将员工的薪资全部增加1000。

    public List<Person> getList(){
        List<Person> personList = new ArrayList<Person>();
        personList.add(new Person("Tom", 8900,12, "male", "New York"));
        personList.add(new Person("Jack", 7000,64, "male", "Washington"));
        personList.add(new Person("Lily", 7800,32, "female", "Washington"));
        personList.add(new Person("Anni", 8200, 20,"female", "New York"));
        personList.add(new Person("Owen", 9500, 80,"male", "New York"));
        personList.add(new Person("Alisa", 7900, 60,"female", "New York"));
        return personList;

    @Test
    public void show10(){
        List<Person> list = getList();
        List<Person> collect = list.stream().map(person -> {
            person.setSalary(person.getSalary() + 1000); //每个人工资加1000块钱
            return person;
        }).collect(Collectors.toList());

        System.out.println("collect = " + collect);

    }

    

案例三：将两个字符数组合并成一个新的字符数组。

    @Test
    public void show11(){
        List<String> list = Arrays.asList("m,k,l,a", "1,2,3,4");
        List<String> collect = list.stream().flatMap(s -> {
            //将每个元素转换成stream
            String[] split = s.split(",");
            Stream<String> stream = Arrays.stream(split);
            return stream;
        }).collect(Collectors.toList());
        System.out.println("处理前" + list);
        System.out.println("处理后" + collect);
    }

5.归纳(reduce)

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作。

案例一：求Integer集合的元素之和、乘积和最大值。

 @Test
    public void show12(){

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        //求和方式一
        Optional<Integer> reduce = list.stream().reduce((x, y) -> x + y);
        //求和方式二
        Optional<Integer> reduce1 = list.stream().reduce(Integer::sum);
        //求和方式三
        Integer reduce2 = list.stream().reduce(0, Integer::sum);

        //求乘法
        Optional<Integer> reduce3 = list.stream().reduce((x, y) -> x * y);

        //求最大值方式1
        Optional<Integer> reduce4 = list.stream().reduce((x, y) -> x > y ? x : y);
        //求最大值方式2
        Integer reduce5 = list.stream().reduce(1, Integer::max);

        System.out.println("   //求和方式一 = " + reduce);
        System.out.println("   //求和方式二 = " + reduce1);
        System.out.println("   //求和方式三 = " + reduce2);
        System.out.println("   // //求乘法 = " + reduce3);
        System.out.println("   //求最大值方式1 = " + reduce4);
        System.out.println("   //求最大值方式2 = " + reduce5);
    }

案例二：求所有员工的工资之和和最高工资。

    @Test
    public void show13(){
        //获取数据
        List<Person> list = getList();

        //求和方式一
        Optional<Integer> reduce1 = list.stream().map(Person::getSalary).reduce(Integer::sum);
        //求和方式二
        Integer reduce2 = list.stream().reduce(0, (sum, p) -> sum += p.getSalary(), (sum1, sum2) -> sum1 + sum2);
        //求和方式三
        Integer reduce3 = list.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::sum);
       // Integer reduce6= list.stream().reduce(0, (sum, p) -> sum += p.getSalary(), Integer::min);

        //求最高工资方式1
        Integer reduce4 = list.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(), Integer::max);
        //求最高工资方式2
        Integer reduce5 = list.stream().reduce(0, (max, p) -> max > p.getSalary() ? max : p.getSalary(), (max1, max2) -> max1 > max2 ? max1 : max2);
        System.out.println("//求和方式一 = " + reduce1);
        System.out.println("//求和方式二 = " + reduce2);
        System.out.println("//求和方式三 = " + reduce3);
        System.out.println("//求最高工资方式1 = " + reduce4);
        System.out.println("//求最高工资方式2 " + reduce5);
   


    }

6.收集(collect)

collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。

collect主要依赖java.util.stream.Collectors类内置的静态方法。

1.归集

因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。toList、toSet和toMap比较常用，另外还有toCollection、toConcurrentMap等复杂一些的用法。

    @Test
    public void show17(){

        List<Integer> list = Arrays.asList(5, 8, 6, 9, 7, 2, 3, 6, 9, 8, 7, 4, 4, 8, 5, 9, 10);
        //把大于3的收集并创建一个信的集合
        List<Integer> collect = list.stream().filter(o -> o > 3).collect(Collectors.toList());
        //把取模等于0的数字放到一个新的集合中
        Set<Integer> collect1 = list.stream().filter(o -> o % 2 == 0).collect(Collectors.toSet());

        List<Person> list1 = getList();
        //把对象工资大于8000的
        Map<String, Person> collect2 = list1.stream().filter(p -> p.getSalary() > 8000).collect(Collectors.toMap(Person::getName, p -> p));

        System.out.println("     //把大于3的收集并创建一个信的集合 = " + collect);
        System.out.println("  //把取模等于0的数字放到一个新的集合中 = " + collect1);
        for (Map.Entry<String, Person> stringPersonEntry : collect2.entrySet()) {
            String key = stringPersonEntry.getKey();
            Person value = stringPersonEntry.getValue();

            System.out.println( "key="+key +"value = " + value);
        }

    }

2.统计

Collectors提供了一系列用于数据统计的静态方法：

计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble

案例：统计员工人数、平均工资、工资总额、最高工资

    @Test
    public void show18(){
        List<Person> list = getList();
        //求总数
        Long collect = list.stream().collect(Collectors.counting());
        //求平均工资
        Double collect1 = list.stream().collect(Collectors.averagingDouble(Person::getSalary));
        //求工资总和
        Integer collect2 = list.stream().collect(Collectors.summingInt(Person::getSalary));
        //一次性统计所有信息
        DoubleSummaryStatistics collect3 = list.stream().collect(Collectors.summarizingDouble(Person::getSalary));
        System.out.println("   //求总数 = " + collect);
        System.out.println("   //求平均工资 " + collect1);
        System.out.println("   //求工资总和" + collect2);
        System.out.println("   //一次性统计所有信息" + collect3);

        //求总数 = 6
        //求平均工资 8216.666666666666
        //求工资总和49300
        //一次性统计所有信息DoubleSummaryStatistics{count=6, sum=49300.000000, min=7000.000000, average=8216.666667, max=9500.000000}

    }

3.分组

• 分区：将stream按条件分为两个Map，比如员工按薪资是否高于8000分为两部分。
• 分组：将集合分为多个Map，比如员工按性别分组。有单级分组和多级分组

    @Test
    public void show123(){
   //获取数据
        List<Person> list = getList();
        //按员工的的性别分组
        Map<String, List<Person>> collect = list.stream().collect(Collectors.groupingBy(Person::getSex));
        //按照员工薪资是否高于8000分组
        Map<Boolean, List<Person>> collect1 = list.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 8000));
        //将员工先按性别分组，在地区分组
        Map<String, Map<String, List<Person>>> collect2 = list.stream().collect(Collectors.groupingBy(Person::getSex, Collectors.groupingBy(Person::getArea)));
        System.out.println(" //按员工的的性别分组 " + collect);
        System.out.println(" //按照员工薪资是否高于8000分组 " + collect1);
        System.out.println("  //将员工先按性别分组，在地区分组 " + collect2);

    }

4.接合

joining可以将stream中的元素用特定的连接符（没有的话，则直接连接）连接成一个字符串。

    @Test
    public void show20(){
        List<Person> list = getList();
        String collect = list.stream().map(o -> o.getName()).collect(Collectors.joining("-"));
        System.out.println("collect = " + collect);  
        //collect = Tom-Jack-Lily-Anni-Owen-Alisa //所有的员工使用"-"字符串连接
        

    }

5.归约

Collectors类提供的reducing方法，相比于stream本身的reduce方法，增加了对自定义归约的支持

    @Test
    public void show21(){
        List<Person> list = getList();
        Integer collect = list.stream().collect(Collectors.reducing(0, Person::getSalary, (i, o) -> (i + o - 5000)));

        System.out.println("collect = " + collect);
        //工资总和
        Optional<Integer> reduce = list.stream().map(Person::getSalary).reduce(Integer::sum);
        System.out.println("reduce.get() = " + reduce.get());


    }

7.排序

sorted，中间操作。有两种排序：

• sorted()：自然排序，流中元素需实现Comparable接口
• sorted(Comparator com)：Comparator排序器自定义排序

    @Test
    public void show22(){
        List<Person> list = getList();
        //根据工资升序排序(自然排序)
        List<Person> collect = list.stream().sorted(Comparator.comparing(Person::getSalary)).collect(Collectors.toList());
        //根据工资倒序排序
        List<String> collect1 = list.stream().sorted(Comparator.comparing(Person::getSalary).reversed()).map(Person::getName).collect(Collectors.toList());


        //先按工资在按年龄升序
        List<Person> collect2 = list.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).collect(Collectors.toList());

        //先按工资在按年龄降序
        List<String> collect3 = list.stream().sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge).reversed()).map(Person::getName).collect(Collectors.toList());


        //自定义
        // 先按工资再按年龄自定义排序（降序）
        List<String> collect4 = list.stream().sorted((p1, p2) -> {
            if (p1.getSalary() == p2.getSalary()) {
                return p2.getAge() - p1.getAge();
            } else {
                return p2.getSalary() - p1.getSalary();
            }
        }).map(Person::getName).collect(Collectors.toList());


        System.out.println(" //根据工资升序排序(自然排序)" + collect);
        System.out.println("  //根据工资倒序排序" + collect1);
        System.out.println("  //先按工资在按年龄升序" + collect2);
        System.out.println("   //先按工资在按年龄降序" + collect3);
        System.out.println(" // 先按工资再按年龄自定义排序（降序）" + collect4);

                     //先按工资在按年龄降序[Owen, Tom, Anni, Alisa, Lily, Jack]
        // 先按工资再按年龄自定义排序（降序）[Owen, Tom, Anni, Alisa, Lily, Jack]
    }

8.提取/组合

流也可以进行合并、去重、限制、跳过等操作。

    @Test
    public void show23(){
    String[] arr1={"a","b","c","c","o"};
    String[] arr2={"q","b","t","d","p"};

    //获取流
        Stream<String> arr11 = Stream.of(arr1);
        Stream<String> arr12 = Stream.of(arr2);

        //合并两个流
        List<String> collect = Stream.concat(arr11, arr12).distinct().collect(Collectors.toList());
        //limit:限制流中获得前n个数据
        List<String> collect1 = collect.stream().limit(3).collect(Collectors.toList());

        //跳过n个数据获取
        List<String> collect2 = collect.stream().skip(2).collect(Collectors.toList());

        System.out.println("//合并两个流 " + collect);
        System.out.println(" //limit:限制流中获得前n个数据 " + collect1);
        System.out.println("  //跳过n个数据获取 " + collect2);

        //合并两个流 [a, b, c, o, q, t, d, p]
        //limit:限制流中获得前n个数据 [a, b, c]
        //跳过n个数据获取 [c, o, q, t, d, p]

    }