简单明了的总结要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