十五、Stream 流操作

流的简单使用

        Integer[] nums = {1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(nums);

        // 过滤掉 不是 > 2 的，并统计元素数量
        long count = list.stream().filter(n -> n > 2).count();
        System.out.println(count);
        // 上面过程的并行版
        count = list.parallelStream().filter(n -> n > 2).count();
        System.out.println(count);

流的获取

        Integer[] nums = {1, 2, 3, 4, 5};
        List<Integer> list = Arrays.asList(nums);


        // 1、将 Collection 转为 Stream
        // Collection 接口下的 stream 和 parallelStream 方法 可以返回一个 Stream
        Stream<Integer> stream = list.stream();
        // 并行流，后续操作会以并行方式运行
        Stream<Integer> stream1 = list.parallelStream();


        // 2、Steam.of 方法直接传入对象
        // public static<T> Stream<T> of(T... values)
        // 这里如果传入 基本类型的数组的话， int[] ,泛型对不上，nums 会作为 int[] 类型的一个参数被传递
        Stream<Integer> stream2 = Stream.of(nums);
        stream2.forEach(System.out::println); // [I@11096447
        stream2 = Stream.of(1, 2, 3, 6);

        // 产生一个不包含任何元素的流
        Stream.empty();

        // 产生一个无限长度的流,每个结果由参数中的函数过程生成的返回值
        stream2 = Stream.generate(() -> 1);
        // 如产生一个随机数流
        Random random = new Random();
        stream2 = Stream.generate(random::nextInt);
        stream2 = Stream.generate(() -> random.nextInt(100));

        // 产生一个无限长度的流，设置一个初始结果，每次生成的结果会作为下一次生产过程的参数
        // 如产生一个自增流
        stream2 = Stream.iterate(0, n -> ++n);
        Stream<BigInteger> stream22 = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));


        // 3、将数组转换为 Stream
        // Arrays.stream 方法
        // 产生一个 从起始下标，到结束下标（不包括结束下标）的流
        Stream<Integer> stream3 = Arrays.stream(nums, 0, 4);


        // 还有其他很多 类都自带产生流的 方法 如 Pattern.splitAsStream 、 Files.lines

流的转换

将流做一些处理并返回一个流

        Integer[] nums = {1, 2, 3, 4, 5};
        Stream<Integer> stream = Arrays.stream(nums);


        // 流操作一次后不能再次操作，这里不用 stream 重新接收新的流的话，后面再次操作会报错错
        // stream.filter(n -> n > 2);

        // 过滤，将返回 true 的结果作为新的流返回
        stream=stream.filter(n -> n > 2);

        // 对每个元素进行操作，将传入的函数应用到每个元素上，函数的返回值作为每个元素的新值
        stream=stream.map(n->n*10);


        Stream<String> stringStream=Stream.of("what","is","your","name");
        // flatMap 将流里的每个元素都转换为流，再将这些流 合成为一个流返回
        stringStream.flatMap(w->{
            char[] chars = w.toCharArray();
            List<Character> list=new ArrayList<>();
            for(Character c:chars)list.add(c);
            return list.stream();
        }).forEach(System.out::print);

抽取子流和连接流

        Integer[] nums = {1, 2, 3, 4, 5 ,6 ,7, 8};
        Stream<Integer> stream = Arrays.stream(nums);


        // 截取流的 前 n 个元素，作为新的流返回
        stream=stream.limit(4);  // 1 2 3 4

        // 丢弃前 n 个元素，将剩余的元素作为新流返回
        stream=stream.skip(2);  // 3 4      1234跳过前两个剩下34

        // 生成一个 有 100 个随机数的流
        Stream.generate(Math::random).limit(1000);


        Stream<Integer> stream2 = Arrays.stream(nums);
        Stream<Integer> stream3 = Arrays.stream(nums);

        // 拼接两个流 ，第一个流不应该是无限的，否则第二个流始终用不到，没有意义
        stream=Stream.concat(stream2,stream3);  // 1.2.3···8.1.2.3···8


        // 去重，返回一个去掉重复元素的流
        stream.distinct();

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

流的转换 2

        // 流排序
        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // 调用 sorted 方法获得一个经过排序的流
        stream=stream.sorted();

        // 传入 比较器  ，传入了一个逆序的比较器，做逆序
        stream=stream.sorted(Comparator.comparing(n->(Integer)n).reversed());



        // 返回一个流，并且当这个流取出元素的时候，会先执行这里的函数过程
        stream=stream.peek(e-> System.out.print("本次使用的元素是"+e+"---"));

        // 这里 调用 forEach 会取出元素，每次取出元素会先输出 本次使用的元素是X 在执行这里的过程
        // 如果没有调用forEach ,也就是没有取出元素，你会发现 peek 方法中的函数过程并不会执行
        stream.forEach(System.out::print); // 本次使用的元素是9---9本次使用的元素是8---8本次使用的元素是7---7 ···

简单约简 ，终结流的操作，将流转为非流值

        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // 获取流元素数
        long counts=stream.count();


        stream = Arrays.stream(nums);
        // 获取流元素中最大的 （min方法与之用法相同）
        Optional<Integer> max = stream.max(Integer::compare);
        // 获得实际值，参数是当获取不到的时候的默认值
        Integer iMax = max.orElse(0);



        stream = Arrays.stream(nums).filter(n->n>6);
        // 返回第一个匹配的元素
        Optional<Integer> first = stream.findFirst();


        stream = Arrays.stream(nums).filter(n->n>6);
        // 返回任何一个匹配元素，在并行处理流的时候比较有效
        Optional<Integer> any = stream.findAny();



        boolean b;
        // 是否全部匹配
        b=Arrays.stream(nums).allMatch(n->n>1); // false
        // 是否存在匹配
        b=Arrays.stream(nums).anyMatch(n->n>2); // true
        // 是否没有匹配
        b=Arrays.stream(nums).noneMatch(n->n>10);// true
        System.out.println(b);

Optional 类型

        Long[] nums = {6L,3L,1L,4L,5L,3L,9L,7L,6L,4L,2L,1L,8L};
        Stream<Long> stream = Arrays.stream(nums);

        // stream 的一些方法会返回一个包含结果的 Optional 对象
        Optional<Long> first = stream.filter(n -> n > 6L).findFirst();

        Long l;
        // 获得Optional中的值 ，如果没有则返回 传入的 替代物
        l=first.orElse(0L);

        // 当没有值的时候 还可以调用代码获取替代值，（只有在需要替代值的时候才会调用代码）
        l=first.orElseGet(()-> new Date().getTime());

        // 当没有值的时候 抛出异常
        //l= first.orElseThrow(Exception::new);

        // 只有当值存在的时候 调用
        first.ifPresent(System.out::println);

        // 将结果值处理并包装返回
        // 如果 first 有值，返回包装处理结果的 Optional ，
        // 如果 first 没有值，返回空的 Optional(是没有值的一个 Optional 对象，不是返回 null)
        Optional<Integer> aBoolean = first.map((n) -> n==9?1:2);

        // 返回 Optional 中的值，没有值的时候会抛异常，不推荐用
        first.get();
        // 返回一个 boolean 表示是否有值
        first.isPresent();


        /// 创建 Optional 的方法
        // 产生一个 Optional 对象，如果 传入的是 null 会抛异常
        Optional<Integer> integer = Optional.of(2);

        // 产生一个 Optional 对象，如果传入的是 null 会返回一个没有值的 Optional 对象
        Optional<Object> o = Optional.ofNullable(null);

        // 产生一个没有值的 Optional 对象
        Optional<Object> empty = Optional.empty();

        // 将值 处理，并包装成 Optional 并返回
        Optional<String> s = first.flatMap(m -> Optional.ofNullable(m.toString()));

收集结果-流转集合

        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // 获取 Iterator 来遍历流中的元素
        Iterator<Integer> iterator = stream.iterator();

        // 遍历每个元素并应用函数
        // 在并行流上是没有顺序的
        Arrays.stream(nums).parallel().forEach(System.out::print); // 9674421358316   9674331126458  9673216445138

        // 会按顺序遍历，但是会导致并行处理的性能优势基本丧失
        Arrays.stream(nums).parallel().forEachOrdered(System.out::print);

        // 获得由流元素组成的数组
        Object[] objects = Arrays.stream(nums).toArray();
        // 传入数组构造器，来获得正确的数组类型
        Integer[] integers = Arrays.stream(nums).toArray(Integer[]::new);

        // 获取流元素组成的 集合，可以传入 集合的构造器
        TreeSet<Integer> collect2 = Arrays.stream(nums).collect(Collectors.toCollection(TreeSet::new));
        // 获取流元素组成的 List
        List<Integer> collect = Arrays.stream(nums).collect(Collectors.toList());
        // 获取流元素组成的 Set
        Set<Integer> collect1 = Arrays.stream(nums).collect(Collectors.toSet());

        // 产生一个整型的对象收集器（收集过程中可以处理元素），利用收集器可以获得 平均、 最大、最小、总和、结果个数
        // 有对应的 long double 版本
        IntSummaryStatistics summaryStatistics = Arrays.stream(nums).collect(Collectors.summarizingInt(n -> n));
        summaryStatistics.getAverage();
        summaryStatistics.getCount();
        summaryStatistics.getMax();
        summaryStatistics.getMin();
        summaryStatistics.getSum();



        String[] words = {"zs","ls","ww"};
        Stream<String> wordsStream = Arrays.stream(words);

        // 可以将 流中的字符串拼接
        String collect3 = wordsStream.collect(Collectors.joining());
        // 设置分隔符
        wordsStream.collect(Collectors.joining(","));
        // 设置分隔符 ，前缀，后缀
        wordsStream.collect(Collectors.joining(",","^","$"));

收集到映射表中 Steam 转 Map

        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // 流转为 Map ，第一参数是 map 键的获取过程，第二个参数是 map 值的获取过程 ，如果键冲突会抛异常
        //Map<Integer, String> map = stream.collect(Collectors.toMap(n -> n, n -> n.toString()));

        // 第三个参数，指明当键冲突的时候，可以如何处理旧值（原来存在的值）和新值，作为此键对应的值
        Map<Integer, String> map2 = Arrays.stream(nums).collect(Collectors.toMap(n -> n, n -> n.toString(),(oldValue,newValue)->oldValue));

        // 转并发线程安全的 map
        // ConcurrentMap<Integer, String> concurrentMap = Arrays.stream(nums).collect(Collectors.toConcurrentMap(n -> n, n -> n.toString()));


        // 将元素分组，每组保存 到 list 中
        Map<String, List<Integer>> collect = Arrays.stream(nums).collect(Collectors.groupingBy(n -> n>2?"大于2":"小于等于2"));
        System.out.println(collect); // {大于2=[6, 3, 4, 5, 3, 7, 9, 6, 4, 8], 小于等于2=[1, 2, 1]}
        // 取得并发线程安全 map 版
        Map<String, List<Integer>> collect2 = Arrays.stream(nums).collect(Collectors.groupingByConcurrent(n -> n>2?"大于2":"小于等于2"));
        System.out.println(collect2); // {大于2=[6, 3, 4, 5, 3, 7, 9, 6, 4, 8], 小于等于2=[1, 2, 1]}

        // 如果只分两组，可以使用以 boolean 为键的版本，其效率要 比 groupingBy 高
        Map<Boolean, List<Integer>> collect1 = Arrays.stream(nums).collect(Collectors.partitioningBy(n -> n > 2 ? true : false));
        System.out.println(collect1); // {false=[1, 2, 1], true=[6, 3, 4, 5, 3, 7, 9, 6, 4, 8]}

下游收集器， groupingBy 的后续

收集到 Map， groupingBy 的扩展，可对收集到的 list 做进一步转换

        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // toSet() :对 收集到的 map list 型 值，转换成 set
        Map<String, Set<Integer>> collect = stream.collect(Collectors.groupingBy(n -> n > 2 ? "大于2" : "小于等于2", Collectors.toSet()));
        System.out.println(collect); // {大于2=[3, 4, 5, 6, 7, 8, 9], 小于等于2=[1, 2]}

        // summingInt: 对 收集到的 map 各个list 型值 ，分别求各个list中的元素 和 ， 这个例子 就是对 大于 2和 小于2 的分别求和 返回到一个 map
        // summingInt  还有对应 double long 版本
        // a->a  这里是将 list 中的数据转成 int 型的过程，因为本来list中的元素就是 int 型，所以不做任何处理返回, 也可以使用 Function.identity() 同样的效果
        Map<String, Integer> collect1 = Arrays.stream(nums).collect(Collectors.groupingBy(n -> n > 2 ? "大于2" : "小于2", Collectors.summingInt(a -> a)));
        System.out.println(collect1); // {小于2=4, 大于2=55}

        // counting :对 收集到的 map 各个list 型值 ，分别求各个list中的元素 数目
        Map<String, Long> collect2 = Arrays.stream(nums).collect(Collectors.groupingBy(n -> n > 2 ? "大于2" : "小于2", Collectors.counting()));
        System.out.println(collect2); // {小于2=3, 大于2=10}

        // 对 收集到的 map 各个list 型值 ，分别求各个list中的元素 最大元素 对应还有 minBy
        Map<String, Optional<Integer>> collect3 = Arrays.stream(nums).collect(Collectors.groupingBy(n -> n > 2 ? "大于2" : "小于2", Collectors.maxBy(Integer::compare)));
        System.out.println(collect3); // {小于2=Optional[2], 大于2=Optional[9]}


        // mapping
        // 对 收集到的 map 各个list 型值 ，分别对各个list中的元素做一层处理后，再交给后续的 Collectors
        Map<String, List<String>> collect4 = Arrays.stream(nums).collect(
                Collectors.groupingBy(n -> n > 2 ? "大于2" : "小于2",
                        Collectors.mapping(n -> "c"+n.toString(),
                                Collectors.mapping(n->n,Collectors.toList()))));
        System.out.println(collect4); // {小于2=[c1, c2, c1], 大于2=[c6, c3, c4, c5, c3, c7, c9, c6, c4, c8]}

约简操作 Stream.reduce

        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // reduce :和 ConCurrentHashMap.reduce 类似
        // 将前一次的处理结果作为参数，参与下一次处理
        // 即  result = v1 op v2 op v3 op v4 ····  op 必须满足 ，x op y op z = x op ( y op z )
        // op 例 ： 求和，乘积，字串拼接，max,min,并集，交集···
        Optional<Integer> reduce = stream.reduce((x, y) -> x + y);

        // 第一个参数为 幺元 e , 幺元满足  e op v = v
        // 当流为 null ，会返回 幺元
        Integer reduce1 = Arrays.stream(nums).reduce(0, (x, y) -> x + y);
        System.out.println(reduce1);

        // 第一个参数为 幺元
        // 第二个参数为 op
        // 第三个参数为，多线程将 不同分组的结果 合并的方式（内部使用了 fork-join框架）
        String reduce2 = Arrays.stream(nums).reduce("x", (x, y) -> x +"-"+ y.toString(), (x, y) -> x +"*" +y);
        System.out.println(reduce2); // x-6-3-1-4-5-3-7-9-6-4-2-1-8

        String reduce4 = Arrays.stream(nums).parallel().reduce("x", (x, y) -> x +"-"+ y.toString(), (x, y) -> x +"*" +y);
        System.out.println(reduce4); // x-6*x-3*x-1*x-4*x-5*x-3*x-7*x-9*x-6*x-4*x-2*x-1*x-8


        Integer reduce3 = Arrays.stream(new String[]{"zs", "ls", "zll"}).parallel().reduce(0, (a, b) -> a + b.length(), (a, b) -> +a + b);
        System.out.println(reduce3); // 7

基本类型流

        // 将基本类型包装成对象使用，效率会降低，可以使用基本类型专属的流，以int为例

        int[] nums={1,6,8,9,7,6};
        IntStream intStream = IntStream.of(1, 3, 6, 4, 9, 8);
        IntStream stream = Arrays.stream(nums);

        OptionalInt first = stream.findFirst();
        OptionalInt max = stream.max();

        IntSummaryStatistics intSummaryStatistics = stream.summaryStatistics();
        intSummaryStatistics.getSum();
        intSummaryStatistics.getMax();
        intSummaryStatistics.getAverage();
        intSummaryStatistics.getCount();

        // 产生步长为 1 的流 ，int 和 lang 专有 ,包括 10
        IntStream range = IntStream.range(1, 10);
        range.forEach(System.out::print);
        // 不包括 10
        IntStream range2 = IntStream.rangeClosed(1, 10);
        range2.forEach(System.out::print);

        int[] ints = stream.toArray();


        // 产生包装器对象流
        Stream<Integer> boxed = stream.boxed();

并行流的获取

        Integer[] nums = {6,3,1,4,5,3,7,9,6,4,2,1,8};
        Stream<Integer> stream = Arrays.stream(nums);

        // 产生一个 与当前 stream 元素相同的 并行流
        Stream<Integer> parallel = stream.parallel();
        // 产生一个 与当前 stream 元素相同 的无序流
        stream.unordered();

        Collection collection=new ArrayList();

        collection.stream();
        // 根据当前集合产生一个 并行流
        collection.parallelStream();