测试 Collectors 类中相关 API，以及 Collector 接口中 Characteristics 的枚举值

    public static void main(String [] args) {
        //Stream API
        List<String> arrList1 = Arrays.asList("predicate1", "collect1", "map1", "flatmap1", "reduce1", "collect1");
        List<String> arrList2 = Arrays.asList("predicate2", "collect2", "map2", "flatmap2", "reduce2", "collect2");
        List<List<String>> arrAll = Arrays.asList(arrList1, arrList2);
        System.out.println(arrList1.stream().filter(i -> i.length() > 5).collect(Collectors.toList()));
        System.out.println(arrList1.stream().map(i -> i.toUpperCase()).collect(Collectors.toList()));
        //flatmap 将流中数据扁平化处理，其中参数二是一个 Stream 对象。本例中将所有字符数组扁平化到一个流中
        arrList1.stream().map(i -> i).flatMap(i -> Stream.of(i.toCharArray())).forEach(i -> System.out.println(Arrays.toString(i)));
        //flatmap 将流中数据扁平化处理，其中参数二是一个 Stream 对象。本例针对的是 List<List<String>> 结构数据，将多个 List 中的数据扁平化到一个流中
        System.out.println(arrAll.stream().flatMap(i -> i.stream()).collect(Collectors.toList()));
        //流元素去重
        System.out.println(arrList1.stream().distinct().collect(Collectors.toList()));
        //流元素排序
        System.out.println(arrList1.stream().sorted(String::compareTo).collect(Collectors.toList()));
        //peek 不影响最终 collect 操作。类似数据预览效果
        System.out.println(arrList1.stream().peek(i -> {
            i += "suffix";
            System.out.println(i);
        }).collect(Collectors.toList()));
        //类似数据库分页查询操作
        System.out.println(arrList1.stream().skip(1).limit(3).collect(Collectors.toList()));
        //遍历消费流中元素
        arrList1.stream().forEach(System.out::println);
        //流转数组
        Object[] objects = arrList1.stream().toArray();
        //通过 i，可以显示的创建一个大小固定的数组
        Object[] strings = arrList1.stream().toArray(i -> {
            System.out.println("i = " + i);
            return new Object[i];
        });
        System.out.println(Arrays.toString(strings));
        //精简写法，并且可以免去泛型强转的问题
        String[] strings1 = arrList1.stream().toArray(String[]::new);
        System.out.println(Arrays.toString(strings1));
        //reduce，汇聚操作，对流中的每个元素按一定规则计算，最终输出一个值，内置的汇聚操作有求和、求平均值、最大值等
        arrList1.stream().reduce((a, b) -> a.concat(b)).ifPresent(i -> System.out.println(i));
        System.out.println(arrList1.stream().reduce("prefix", (a, b) -> a.concat(b)));
        //reduce 的重载形式，计算流中字符的总个数，参数一是一个初始值
        System.out.println(arrList1.stream().reduce(0, (a, b) -> a += b.length(), (a, b) ->  a+= b));
        //求最大值和最小值，本质上使用的就是 reduce
        arrList1.stream().min((a, b) -> a.length() - b.length()).ifPresent(i -> System.out.println(i));
        arrList1.stream().max((a, b) -> a.length() - b.length()).ifPresent(i -> System.out.println(i));
        //求个数（可以使用 peek 配合 reduce，可以同时得出多个汇聚后的值，而不是一个）
        System.out.println(arrList1.stream().count());
        //任意匹配返回 true
        System.out.println(arrList1.stream().anyMatch(i -> "map1".equals(i)));
        //全部匹配返回 true
        System.out.println(arrList1.stream().allMatch(i -> i.length() > 0));
        //全部都不匹配返回 true
        System.out.println(arrList1.stream().noneMatch(i -> i.length() < 0));
        //找出流中第一个元素
        arrList1.stream().findFirst().ifPresent(i -> System.out.println(i));
        //找出流中任意一个元素
        arrList1.stream().findAny().ifPresent(i -> System.out.println(i));
    }


    public static void main1(String[] args) {


        //Collectors API
        StringBuilder builder = Stream.of("supplier", "consumer", "producer")
                .collect(StringBuilder::new, StringBuilder::append, StringBuilder::append);
        System.out.println(builder);
        int[] intArr = Arrays.asList(1, 2, 3, 4, 5).stream()
                .collect(() -> new int[1], (a, b) -> a[0] += b, (a, b) -> a[0] += b[0]);
        System.out.println(Arrays.toString(intArr));
        Collectors collectors;
        Stream.<String>of().collect(Collectors.<String>toList());
        StringJoiner joiner = new StringJoiner(";", "pre", "suf");
        joiner.add("supplier").add("consumer").add("producer");
        System.out.println("merge : " + joiner.toString());
        List<String> list = Arrays.asList("supplier", "consumer", "producer");
        //在应用一个下游收集器之前，对流中的元素做一次 map 转换
        System.out.println(list.stream().collect(Collectors.mapping(String::toUpperCase, Collectors.toList())));
        //先应用了一个下游收集器，然后对下游收集器的结果应用一个 Function 进行转换。理解 Charactristic 的几个枚举值
        String collect = list.stream().collect(Collectors.collectingAndThen(Collectors.toList(), r -> StringUtils.join(r, ";")));
        System.out.println(collect);
        List<Integer> nums = Arrays.asList(1, 3, 5, 7, 9, 11);
        System.out.println("couting1 : " + nums.stream().collect(Collectors.counting()));
        Integer collect1 = nums.stream().parallel().collect(new Collector<Integer, int[], Integer>() {
            @Override
            public Supplier supplier() { return () -> new int[1]; }

            @Override
            public BiConsumer<int [], Integer> accumulator() { return (a, b) -> a[0] = 1; }

            @Override
            public BinaryOperator<int []> combiner() {
                return (a, b) -> {
                    System.out.println("a = " + a + " , b = " + b);
                    System.out.println(Thread.currentThread().getName() + ":" + a[0] + ":" + b[0]);
                    a[0] = a[0] + b[0];
                    return a;
                };
            }
            @Override
            public Function<int [], Integer> finisher() { return (a) -> a[0];}

            @Override
            public Set<Characteristics> characteristics() { return Collections.emptySet();}
        });
        System.out.println("couting2 : " + collect1);
        //其实本质上也是 reduce 的调用，也符合下面的规则，流中元素 -> 输出为一个值
        nums.stream().collect(Collectors.minBy((a, b) -> a - b)).ifPresent(System.out::println);
        nums.stream().collect(Collectors.maxBy((a, b) -> a - b)).ifPresent(System.out::println);
        System.out.println(nums.stream().collect(Collectors.summingInt(a -> a * 2)));
        //reduce 函数的作用是将流中的多个元素，按照某种规则，输出为一个值。比如统计 Count、求和、元素转 String 等
        System.out.println(nums.stream().collect(Collectors.<Integer, String>reducing("", a -> "{" + a + "}", (a, b) -> a + b)));
        Map<String, Object> m1 = new HashMap<>();
        m1.put("a", 123);
        m1.put("b", 456);
        m1.put("c", 789);
        //HashMap 中的这个方法，将新值和旧值合并；旧值就是通过 get("a") 获取，新值就是 111。合并规则由 BinaryOperator 指定
        m1.merge("d", 111, (a, b) -> a + "-" + b);
        System.out.println(m1);
        m1.replaceAll((k, v) -> k + '-' + v);
        System.out.println("after replace All : " + m1);
        for(Map.Entry<String, Object> entry : m1.entrySet()) {
            m1.merge(entry.getKey(), "111", (a, b) -> a + "-" + b);
        }
        System.out.println(m1);
        List<String> list1 = Arrays.asList("aaSupplier11", "ccComsumer12", "ccProducer13", "ccEntry14", "aaMap15", "ccProducer16");
        Map<String, List<String>> result1 = list1.stream().collect(Collectors.groupingBy(a -> a.startsWith("aa") ? "aa" : "bb"));
        System.out.println(result1);
        Map<String, List<String>> result2 = list1.stream().collect(
                Collectors.<String, String, List<String>, List<String>>groupingBy(
                a -> a.startsWith("aa") ? "aa" : "cc", (Collector<? super String, List<String>, List<String>>) Collectors.<String>toList()));
        System.out.println(result2);
        //最底层的 groupBy，需要提供的有：键的分类器、保存结果的 Map 容器、容器中值对应的类型（一般是 List）
        Map<String, Set<String>> result3 = list1.stream().collect(Collectors.<String, String, Set<String>, Set<String>, Map<String, Set<String>>>groupingBy(
                a -> a.startsWith("aa") ? "aa" : "ee",
                () -> new HashMap<String, Set<String>>()
                , (Collector<? super String, Set<String>, Set<String>>) Collectors.<String>toSet()));
        System.out.println(result3);

        //分区，里面有一个对象 Partition，Partition 本质上是一个 Map，并且它的 Key 是 Boolean 类型，该 Map 中仅有两个元素。值是泛型 T，可以是任意类型
        Map<Boolean, List<String>> result = list1.stream().collect(Collectors.partitioningBy(i -> i.startsWith("cc"), Collectors.toList()));
        System.out.println(result);

        //toMap，将流中每个元素按照指定规则，转为 map，但要确保流中的元素不会有重复，否则异常
        Map<String, Integer> result4 = list1.stream().collect(Collectors.toMap(i -> i.toUpperCase(), i -> i.length()));
        System.out.println(result4);

        List<Integer> intList = Arrays.asList(1, 3, 5, 7, 9);
        //这个例子也演示了如何通过自定义类的方式来制作一个容器
        IntSummaryStatistics collect2 = intList.parallelStream().collect(Collectors.summarizingInt(i -> i));
        System.out.println(collect2);

        List<String> list0 = new ArrayList<>();
        List<String> list2 = Arrays.asList("aaSupplier21", "ccComsumer22", "ccProducer23", "ccEntry24", "aaMap25", "ccProducer26");
        List<String> list3 = Arrays.asList("aaSupplier31", "ccComsumer32", "ccProducer33", "ccEntry34", "aaMap35", "ccProducer36");
        list0.addAll(list1);
        list0.addAll(list2);
        list0.addAll(list3);
        System.out.println("-------------");
        Thread.currentThread().setName("ForkJoinPool.commonPool-worker-M");
        //三个枚举值的使用
        for(int i = 0; i < 1; i++) {
            List<String> collect3 = list0.parallelStream().collect(new Collector<String, List<String>, List<String>>() {
                @Override
                public Supplier<List<String>> supplier() {
                    return () -> {
                        System.out.println("do supplier " + Thread.currentThread().getName());
                        return new ArrayList<>();
                    };
                }

                @Override
                public BiConsumer<List<String>, String> accumulator() {
                    return (a, b) -> {
                        a.add(b);
                        //在获取并行流的情况下，如果多线程处理的是一个结果容器，这里不能遍历读取容器中的内容，否则很有可能抛出异常 ConcurrentModificationException
                        //在获取并行流的情况下，除上述情况外，不会有异常出现
                        //System.out.println("do accumulator " + Thread.currentThread().getName() + " " + a);
                    };
                }

                @Override
                public BinaryOperator<List<String>> combiner() {
                    return (a, b) -> {
                        a.addAll(b);
                        System.out.println("do combiner " + Thread.currentThread().getName() + " " + a);
                        return a;
                    };
                }

                @Override
                public Function<List<String>, List<String>> finisher() {
                    return a -> {
                        System.out.println("do finisher " + Thread.currentThread().getName());
                        return a;
                    };
                }

                @Override
                public Set<Characteristics> characteristics() {
                    System.out.println("do characteristics " + Thread.currentThread().getName());
                    //在获取了并行流的前提下，当且仅当同时设置了 UNORDERED 和 CONCURRENT 时，combiner 才不会执行，这是因为多线程中，多线程操作的是同一个结果容器
                    //在获取了并行流的情况下，除上述情况外，其他情况都会执行 combiner，这是因为多线程中，每个线程处理一个结果容器，最后会将多个结果容器汇总起来
                    return Collections.unmodifiableSet(EnumSet.of(Characteristics.CONCURRENT, Characteristics.UNORDERED));
                    //return Collections.emptySet();
                }
            });
            System.out.println(collect3);
        }
    }