Java8(3)Stream类的collect方法详解

参考书籍:《Java 8函数式编程》

上篇Java8之Stream类限于篇幅,所以把Stream的collect方法单独拿出来写一篇文章。
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.toUpperCase(), Collectors.joining(","))));
    

下篇Lambda表达式的真实面目

    原文作者:Namikun
    原文地址: https://www.jianshu.com/p/ccbb42ad9551
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞