经验 - Mark ：Java8 Stream类的collect方法详解

Myth丶恋晨 2022-03-18 06:22 215阅读 0赞

简单明了的总结要Mark

`Stream API`中有两种`collect`方法：

1. <R, A> R collect(Collector<? super T, A, R> collector);
    2. <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);

一般第一种方法用的比较多，第二种方法看起来跟`reduce`的第三种方法有点类似，也可以用来实现`filter、map`等操作，但是两者实现方式有区别。我们以实现`filter`为例：

*  **reduce实现filter功能方式**:

public static <T> List<T> filter(Stream<T> stream, Predicate<T> predicate) {
        return stream.reduce(new ArrayList<T>(), (acc, t) -> {
            if (predicate.test(t)) {
                List<T> lists = new ArrayList<T>(acc);
                lists.add(t);
                return lists;
            }
            return acc;
        }, (List<T> left, List<T> right) -> {
            List<T> lists = new ArrayList<T>(left);
            lists.addAll(right);
            return lists;
        });
    }

*  **collect实现filter功能方式**:

public static <T> List<T> filter(Stream<T> stream, Predicate<T> predicate) {
        return stream.collect(ArrayList::new, (acc, t) -> {
            if (predicate.test(t))
                acc.add(t);
        }, ArrayList::addAll);
    }

很明显collect实现方式更简洁，效率更高。那么reduce为什么每次都`new`一次`ArrayList`，而不是直接`acc.add(t)`再返回`acc`呢？**因为reduce规定第二个参数`BiFunction<U, ? super T, U> accumulator`表达式不能改变其自身参数`acc`原有值，所以每次都要`new ArrayList<T>(acc)`，再返回新的list。**

下面来看看第一种collect方法，它离不开`Collectors`工具类。其实上篇的代码已经涉及到了该方法，比如`collect(Collectors.toList())`转换成list集合。其他API如下：

1.  `Collectors.toSet()`：转换成set集合。
2.  `Collectors.toCollection(TreeSet::new)`：转换成特定的set集合。
    
        TreeSet<Integer> collect2 = Stream.of(1, 3, 4).collect(Collectors.toCollection(TreeSet::new));
3.  `Collectors.toMap(x -> x, x -> x + 1)`：转换成map。
    
        Map<Integer, Integer> collect1 = Stream.of(1, 3, 4).collect(Collectors.toMap(x -> x, x -> x + 1));
4.  `Collectors.minBy(Integer::compare)`：求最小值，相对应的当然也有maxBy方法。
5.  `Collectors.averagingInt(x->x)`：求平均值，同时也有averagingDouble、averagingLong方法。
    
        System.out.println(Stream.of(1, 2, 3).collect(Collectors.averagingInt(x->x)));
6.  `Collectors.summingInt(x -> x))`：求和。
7.  `Collectors.summarizingDouble(x -> x)`：可以获取最大值、最小值、平均值、总和值、总数。
    
        DoubleSummaryStatistics summaryStatistics = Stream.of(1, 3, 4).collect(Collectors.summarizingDouble(x -> x));
         summaryStatistics.getAverage()；//平均值
8.  `Collectors.groupingBy(x -> x)`：有三种方法，查看源码可以知道前两个方法最终调用第三个方法，第二个参数默认`HashMap::new` 第三个参数默认`Collectors.toList()`，参考SQL的groupBy。
    
        Map<Integer, List<Integer>> map = Stream.of(1, 3, 3, 4).collect(Collectors.groupingBy(x -> x));
         Map<Integer, Long> map = Stream.of(1, 3, 3, 4).collect(Collectors.groupingBy(x -> x, Collectors.counting()));
         HashMap<Integer, Long> hashMap = Stream.of(1, 3, 3, 4).collect(Collectors.groupingBy(x -> x, HashMap::new, Collectors.counting()));
9.  `Collectors.partitioningBy(x -> x > 2)`，把数据分成两部分，`key为ture/false`。第一个方法也是调用第二个方法，第二个参数默认为`Collectors.toList()`。
    
        Map<Boolean, List<Integer>> collect5 = Stream.of(1, 3, 4).collect(Collectors.partitioningBy(x -> x > 2));
         Map<Boolean, Long> collect4 = Stream.of(1, 3, 4).collect(Collectors.partitioningBy(x -> x > 2, Collectors.counting()));
10. `Collectors.joining(",")`：拼接字符串。
    
        System.out.println(Stream.of("a", "b", "c").collect(Collectors.joining(",")));
11. `Collectors.reducing(0, x -> x + 1, (x, y) -> x + y))`：在求累计值的时候，还可以对参数值进行改变，这里是都+1后再求和。跟reduce方法有点类似，但reduce方法没有第二个参数。
    
        System.out.println(Stream.of(1, 3, 4).collect(Collectors.reducing(0, x -> x + 1, (x, y) -> x + y)));
12. `Collectors.collectingAndThen(Collectors.joining(","), x -> x + "d")`：先执行collect操作后再执行第二个参数的表达式。这里是先拼接字符串，再在最后+ "d"。
    
        String str= Stream.of("a", "b", "c").collect(Collectors.collectingAndThen(Collectors.joining(","), x -> x + "d"));
13. `Collectors.mapping(...)`：跟map操作类似，只是参数有点区别。
    
        System.out.println(Stream.of("a", "b", "c").collect(Collectors.mapping(x -> x.toUpperCas

consult ：

https://www.jianshu.com/p/ccbb42ad9551