java8之stream流之Collector和Collectors

最新推荐文章于 2023-04-24 13:05:01 发布
最新推荐文章于 2023-04-24 13:05:01 发布
阅读量2.3k 收藏 15
点赞数 1
分类专栏： java
原文链接：https://www.jianshu.com/p/7eaa0969b424
版权

Collector

Collector是专门用来作为Stream的collect方法的参数的。

public interface Stream<T> extends BaseStream<T, Stream<T>> {
    <R, A> R collect(Collector<? super T, A, R> collector);
}

 而Collectors是作为生产具体Collector的工具类。

Collector主要包含五个参数，它的行为也是由这五个参数来定义的，如下所示：

public interface Collector<T, A, R> {
    // supplier参数用于生成结果容器，容器类型为A
    Supplier<A> supplier();
    // accumulator用于消费元素，也就是归纳元素，这里的T就是元素，它会将流中的元素一个一个与结果容器A发生操作
    BiConsumer<A, T> accumulator();
    // combiner用于两个两个合并并行执行的线程的执行结果，将其合并为一个最终结果A
    BinaryOperator<A> combiner();
    // finisher用于将之前整合完的结果R转换成为A
    Function<A, R> finisher();
    // characteristics表示当前Collector的特征值，这是个不可变Set
    Set<Characteristics> characteristics();
}

Collector拥有两个of方法用于生成Collector实例，其中一个拥有上面所有五个参数，另一个四个参数，不包括finisher。

public interface Collector<T, A, R> {
    // 四参方法，用于生成一个Collector，T代表流中的一个一个元素，R代表最终的结果
    public static<T, R> Collector<T, R, R> of(Supplier<R> supplier,
                                              BiConsumer<R, T> accumulator,
                                              BinaryOperator<R> combiner,
                                              Characteristics... characteristics) {/*...*/}
    // 五参方法，用于生成一个Collector，T代表流中的一个一个元素，A代表中间结果，R代表最终结果，finisher用于将A转换为R                                          
    public static<T, A, R> Collector<T, A, R> of(Supplier<A> supplier,
                                                 BiConsumer<A, T> accumulator,
                                                 BinaryOperator<A> combiner,
                                                 Function<A, R> finisher,
                                                 Characteristics... characteristics) {/*...*/}                                              
}

Characteristics：这个特征值是一个枚举，拥有三个值：CONCURRENT（多线程并行），UNORDERED（无序），IDENTITY_FINISH（无需转换结果）。其中四参of方法中没有finisher参数，所以必有IDENTITY_FINISH特征值。

 

collect常见参数

toCollection：将流中的元素全部放置到一个集合中返回，这里使用Collection，泛指多种集合

public class CollectorsTest {
    public static void toCollectionTest(List<String> list) {
        List<String> ll = list.stream().collect(Collectors.toCollection(LinkedList::new));
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        toCollectionTest(list);
    }
}

toList：将流中的元素放置到一个列表集合中去。这个列表默认为ArrayList

public class CollectorsTest {
    public static void toListTest(List<String> list) {
        List<String> ll = list.stream().collect(Collectors.toList());
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        toListTest(list);
    }
}

toSet：将流中的元素放置到一个无序集set中去。默认为HashSet。

public class CollectorsTest {
    public static void toSetTest(List<String> list) {
        Set<String> ss = list.stream().collect(Collectors.toSet());
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        toSetTest(list);
    }
}

joining：joining的目的是将流中的元素全部以字符序列的方式连接到一起，可以指定连接符，甚至是结果的前后缀。

public class CollectorsTest {
    public static void joiningTest(List<String> list){
        // 无参方法
        String s = list.stream().collect(Collectors.joining());
        System.out.println(s);
        // 指定连接符
        String ss = list.stream().collect(Collectors.joining("-"));
        System.out.println(ss);
        // 指定连接符和前后缀
        String sss = list.stream().collect(Collectors.joining("-","S","E"));
        System.out.println(sss);
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        joiningTest(list);
    }
}

 执行结果：

1234567891101212121121asdaa3e3e3e2321eew
123-456-789-1101-212121121-asdaa-3e3e3e-2321eew
S123-456-789-1101-212121121-asdaa-3e3e3e-2321eewE

mapping：这个映射是首先对流中的每个元素进行映射，即类型转换，然后再将新元素以给定的Collector进行归纳。

public class CollectorsTest {
    public static void mapingTest(List<String> list){
        List<Integer> ll = list.stream().limit(5).collect(Collectors.mapping(Integer::valueOf,Collectors.toList()));
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        mapingTest(list);//[123, 456, 789, 1101, 212121121]
    }
}

collectingAndThen：该方法是在归纳动作结束之后，对归纳的结果进行再处理。

public class CollectorsTest {
    public static void collectingAndThenTest(List<String> list){
        int length = list.stream().collect(Collectors.collectingAndThen(Collectors.toList(),e -> e.size()));
        System.out.println(length);
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        collectingAndThenTest(list);//8
    }
}

counting：该方法用于计数。

public class CollectorsTest {
    public static void countingTest(List<String> list){
        long size = list.stream().collect(Collectors.counting());
        System.out.println(size);
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        countingTest(list);//8
    }
}

minBy/maxBy：生成一个用于获取最小/最大值的Optional结果的Collector。

public class CollectorsTest {
    public static void maxByAndMinByTest(List<String> list){
        System.out.println(list.stream().collect(Collectors.maxBy((a,b) -> a.length()-b.length())));
        System.out.println(list.stream().collect(Collectors.minBy((a,b) -> a.length()-b.length())));
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        //Optional[212121121]
        //Optional[123]
        maxByAndMinByTest(list);
    }
}

summingInt/summingLong/summingDouble：生成一个用于求元素和的Collector，首先通过给定的mapper将元素转换类型，然后再求和。参数的作用就是将元素转换为指定的类型，最后结果与转换后类型一致。

public class CollectorsTest {
    public static void summingTest(List<String> list){
        int i = list.stream().limit(3).collect(Collectors.summingInt(Integer::valueOf));
        long l = list.stream().limit(3).collect(Collectors.summingLong(Long::valueOf));
        double d = list.stream().limit(3).collect(Collectors.summingDouble(Double::valueOf));
        System.out.println(i +"\n" +l + "\n" + d);//1368 1368 1368.0
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        summingTest(list);
    }
}

averagingInt/averagingLong/averagingDouble：生成一个用于求元素平均值的Collector，首选通过参数将元素转换为指定的类型。参数的作用就是将元素转换为指定的类型，求平均值涉及到除法操作，结果一律为Double类型。

public class CollectorsTest {
    public static void averagingTest(List<String> list){
        double i = list.stream().limit(3).collect(Collectors.averagingInt(Integer::valueOf));
        double l = list.stream().limit(3).collect(Collectors.averagingLong(Long::valueOf));
        double d = list.stream().limit(3).collect(Collectors.averagingDouble(Double::valueOf));
        System.out.println(i +"\n" +l + "\n" + d);//456.0 456.0 456.0
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        averagingTest(list);
    }
}

reducing：reducing方法有三个重载方法，其实是和Stream里的三个reduce方法对应的，二者是可以替换使用的，作用完全一致，也是对流中的元素做统计归纳作用。

public final class Collectors {
    // 无初始值的情况，返回一个可以生成Optional结果的Collector
    public static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op) {/*...*/}
    // 有初始值的情况，返回一个可以直接产生结果的Collector
    public static <T> Collector<T, ?, T> reducing(T identity, BinaryOperator<T> op) {/*...*/}
    // 有初始值，还有针对元素的处理方案mapper，生成一个可以直接产生结果的Collector，元素在执行结果操作op之前需要先执行mapper进行元素转换操作
    public static <T, U> Collector<T, ?, U> reducing(U identity,
                                    Function<? super T, ? extends U> mapper,
                                    BinaryOperator<U> op) {/*...*/}
}
public class CollectorsTest {
    public static void reducingTest(List<String> list){
        System.out.println(list.stream().limit(4).map(String::length).collect(Collectors.reducing(Integer::sum)));//Optional[13]
        System.out.println(list.stream().limit(3).map(String::length).collect(Collectors.reducing(0, Integer::sum)));//9
        System.out.println(list.stream().limit(4).collect(Collectors.reducing(0,String::length,Integer::sum)));//13
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        reducingTest(list);
    }
}

groupingBy：这个方法是用于生成一个拥有分组功能的Collector，它也有三个重载方法：

public final class Collectors {
    // 只需一个分组参数classifier，内部自动将结果保存到一个map中，每个map的键为?类型（即classifier的结果类型），值为一个list，这个list中保存在属于这个组的元素。
    public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(
            Function<? super T, ? extends K> classifier) {/*...*/}
    // 在上面方法的基础上增加了对流中元素的处理方式的Collector，比如上面的默认的处理方法就是Collectors.toList()
    public static <T, K, A, D>Collector<T, ?, Map<K, D>> groupingBy(
            Function<? super T, ? extends K> classifier,Collector<? super T, A, D> downstream) {/*...*/}
    // 在第二个方法的基础上再添加了结果Map的生成方法。
    public static <T, K, D, A, M extends Map<K, D>>
        Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                                      Supplier<M> mapFactory,
                                      Collector<? super T, A, D> downstream) {/*...*/}
}
public class CollectorsTest {
    public static void groupingByTest(List<String> list){
        Map<Integer,List<String>> s = list.stream().collect(Collectors.groupingBy(String::length));
        Map<Integer,List<String>> ss = list.stream().collect(Collectors.groupingBy(String::length, Collectors.toList()));
        Map<Integer,Set<String>> sss = list.stream().collect(Collectors.groupingBy(String::length,HashMap::new,Collectors.toSet()));
        //{3=[123, 456, 789], 4=[1101], 5=[asdaa], 6=[3e3e3e], 7=[2321eew], 9=[212121121]}
        //{3=[123, 456, 789], 4=[1101], 5=[asdaa], 6=[3e3e3e], 7=[2321eew], 9=[212121121]}
        //{3=[123, 456, 789], 4=[1101], 5=[asdaa], 6=[3e3e3e], 7=[2321eew], 9=[212121121]}
        System.out.println(s.toString() + "\n" + ss.toString() + "\n" + sss.toString());
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        groupingByTest(list);
    }
}

partitioningBy：该方法将流中的元素按照给定的校验规则的结果分为两个部分，放到一个map中返回，map的键是Boolean类型，值为元素的列表List。

该方法有两个重载方法：

public final class Collectors {
    // 只需一个校验参数predicate
    public static <T>
        Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {/*...*/}
    // 在上面方法的基础上增加了对流中元素的处理方式的Collector，比如上面的默认的处理方法就是Collectors.toList()
    public static <T, D, A>
        Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate,
                                                        Collector<? super T, A, D> downstream) {/*...*/}
}
public class CollectorsTest {
    public static void partitioningByTest(List<String> list){
        Map<Boolean,List<String>> map = list.stream().collect(Collectors.partitioningBy(e -> e.length()>5));
        Map<Boolean,Set<String>> map2 = list.stream().collect(Collectors.partitioningBy(e -> e.length()>6,Collectors.toSet()));
        //{false=[123, 456, 789, 1101, asdaa], true=[212121121, 3e3e3e, 2321eew]}
        //{false=[123, 456, 1101, 789, 3e3e3e, asdaa], true=[212121121, 2321eew]}
        System.out.println(map.toString() + "\n" + map2.toString());
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        partitioningByTest(list);
    }
}

toMap：toMap方法是根据给定的键生成器和值生成器生成的键和值保存到一个map中返回，键和值的生成都依赖于元素，可以指定出现重复键时的处理方案和保存结果的map。

public final class Collectors {
    // 指定键和值的生成方式keyMapper和valueMapper
    public static <T, K, U>
        Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                        Function<? super T, ? extends U> valueMapper) {/*...*/}
    // 在上面方法的基础上增加了对键发生重复时处理方式的mergeFunction，比如上面的默认的处理方法就是抛出异常
    public static <T, K, U>
        Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                        Function<? super T, ? extends U> valueMapper,
                                        BinaryOperator<U> mergeFunction) {/*...*/}
    // 在第二个方法的基础上再添加了结果Map的生成方法。
    public static <T, K, U, M extends Map<K, U>>
        Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper,
                                    BinaryOperator<U> mergeFunction,
                                    Supplier<M> mapSupplier) {/*...*/}
}
public class CollectorsTest {
    public static void toMapTest(List<String> list){
        Map<String,String> map = list.stream().limit(3).collect(Collectors.toMap(e -> e.substring(0,1),e -> e));
        Map<String,String> map1 = list.stream().collect(Collectors.toMap(e -> e.substring(0,1),e->e,(a,b)-> b));
        Map<String,String> map2 = list.stream().collect(Collectors.toMap(e -> e.substring(0,1),e->e,(a,b)-> b,HashMap::new));
        //{1=123, 4=456, 7=789}
        //{a=asdaa, 1=1101, 2=2321eew, 3=3e3e3e, 4=456, 7=789}
        //{a=asdaa, 1=1101, 2=2321eew, 3=3e3e3e, 4=456, 7=789}
        System.out.println(map.toString() + "\n" + map1.toString() + "\n" + map2.toString());
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        toMapTest(list);
    }
}

第一种方式中，如果不添加limit限制，就会抛出异常。

还有并发的版本：toConcurrentMap,同样三种重载方法，与toMap基本一致，只是它最后使用的map是并发Map:ConcurrentHashMap。

 

summarizingInt/summarizingLong/summarizingDouble：这三个方法适用于汇总的，返回值分别是IntSummaryStatistics，LongSummaryStatistics，DoubleSummaryStatistics。在这些返回值中包含有流中元素的指定结果的数量、和、最大值、最小值、平均值。所有仅仅针对数值结果。

public class CollectorsTest {
    public static void summarizingTest(List<String> list){
        IntSummaryStatistics intSummary = list.stream().collect(Collectors.summarizingInt(String::length));
        LongSummaryStatistics longSummary = list.stream().limit(4).collect(Collectors.summarizingLong(Long::valueOf));
        DoubleSummaryStatistics doubleSummary = list.stream().limit(3).collect(Collectors.summarizingDouble(Double::valueOf));
        //IntSummaryStatistics{count=8, sum=40, min=3, average=5.000000, max=9}
        //LongSummaryStatistics{count=4, sum=2469, min=123, average=617.250000, max=1101}
        //DoubleSummaryStatistics{count=3, sum=1368.000000, min=123.000000, average=456.000000, max=789.000000}
        System.out.println(intSummary.toString() + "\n" + longSummary.toString() + "\n" + doubleSummary.toString());
    }
    public static void main(String[] args) {
        List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
        summarizingTest(list);
    }
}

整个Collectors工具类就是在为Collector服务，用于创建各种不同的Collector。部分功能与Stream中的方法重合了，为了简化代码，完全不必采用Collectors实现，优先Stream方法。


 

collectors 求和_JDK Collectors与Collector
weixin_31364787的博客
12-30 391
起因：前段时间开始了解并使用Stream流式计算，其中collect()的方法使用很多情况下需要去百度。又因为它的名字与之前写的集合框架工具类JDK Collections工具类 比较像。所以一直想要写一篇博客来记录和学习一下。????Collectors与Collector位于java.util.stream包下，为stream流式计算提供方便的。1.Collector(interface)Colle...
Java中stream流及Collectors的常见用法详细汇总！！！
最新发布
qq_45774406的博客
09-21 1755
Java中stream流及Collectors的常见用法详细汇总！！！
Java基础系列-Collector和Collectors
瓦莉拉啦啦的博客
08-11 652
Java基础系列-Collector和Collectors
Java Stream API进阶篇
weixin_30633405的博客
03-15 170
本文github地址 上一节介绍了部分Stream常见接口方法，理解起来并不困难，但Stream的用法不止于此，本节我们将仍然以Stream为例，介绍流的规约操作。 规约操作（reduction operation）又被称作折叠操作（fold），是通过某个连接动作将所有元素汇总成一个汇总结果的过程。元素求和、求最大值或最小值、求出元素总个数、将所有元素转换成一个列表或集合，都属于规约操作。Stre...
Java8 Stream之Collectors
借物小人的博客
06-15 1882
Collectors 是 Java 8 加入的操作类，位于 java.util.stream 包下。它会根据不同的策略将元素收集归纳起来，比如最简单常用的是将元素装入Map、Set、List等可变容器中
stream流（Collectors）用法
linsa_pursuer的博客
06-21 392
stream流用法
Java 8 Stream API中的`Collectors.collectingAndThen()`：转换结果的利器
09-15
在Java 8引入的Stream API中，Collectors类提供了多种收集器（Collector），用于将流（Stream）的元素汇总成各种形式的结果。Collectors.collectingAndThen()是其中一种强大的收集器，它允许开发者在收集过程完成后...
Java 8 Stream API中的`Collectors.toList()`：详细解析与应用
09-15
Collectors.toList()是Java 8 Stream API中一个非常实用的工具，它简化了将流中的元素收集到列表中的过程。通过本文的详细介绍，你应该能够理解Collectors.toList()的工作原理，并能够在实际开发中灵活运用它。如果...
Java 8 Stream API中的`Collectors.joining()`：字符串连接的艺术
09-15
其中，Collectors.joining()方法是一个专门用于字符串连接的Collector，它提供了一种简洁且高效的方式来将流中的元素合并成一个单一的字符串。本文将深入探讨Collectors.joining()的工作原理、使用场景、性能优化...
Java8Test.java_java8_almosttog_stream流_
09-29
Java 8是Java语言的一个重要版本，引入了许多新特性，其中Stream API是其最显著的改进之一。Stream API提供了一种新的数据处理方式，使得在集合上进行操作更加简洁、高效。本文将深入探讨Java 8 Stream API的基础...
java8之stream使用之Collector
小小雨伞的博客
05-12 210
public class Stream_03 { /** * Collector<T,A,R> * T : 需要进行reduce操作的元素类型 * A : reduce操作的动态集合类型 * R : 还原操作的结果类型 * Collector是专门用来作为Stream的collect方法的参数的。 */ //Collectors是产生Collector的工具类 public static void main(
Collector和Collectors类（收集器原理分析）
qq_43621307的博客
01-07 1275
Collector收集器源码分析
Java8 Stream Collectors
zym_1321的博客
06-11 251
Collectors 类实现了很多归约操作，例如将流转换成集合和聚合元素。返回列表、字符串、或产生统计结果的收集器 实例如下： static class Student { private String address; private String name; private Integer age; public Stude...
java stream 之Collector
qq_26471769的博客
03-24 1451
lambda,collector.of()
collections求和方法_Java8中Collectors求和功能的自定义扩展
weixin_39883374的博客
12-20 431
起因业务中需要将一组数据分类后收集总和，原本可以使用Collectors.summingInt()，但是我们的数据源是BigDecimal类型的，而Java8原生只提供了summingInt、summingLong、summingDouble三种基础类型的方法。于是就自己动手丰衣足食吧。。期望目标：Map result = Arrays.stream(records).parallel().col...
collectors 求和_Collectors工具类
weixin_39858245的博客
12-20 378
public classCollectors_example {public static voidmain(String[] args) {List appleList = new ArrayList<>();appleList.add(new Apple("red", 170));appleList.add(new Apple("green", 150));appleList.ad...
JDK8新特性(十一)之流(Stream)收集器(Collectors)
北辰
12-12 1296
JDK8新特性之流(Stream)收集器(Collectors)
关于linq的groupby 的应用
weixin_40029679的博客
09-14 334
var group = MailCanyuList.GroupBy(x => x.ResponsibleUnit);//一单位名称为基点来分组mail本身对list进行分组 获取其中的 key值 oneRow.UnitName = oneInGroup.Key;//key为当前分组分类的名称 foreach (var oneInGroup in group) { oneInGroup.ToList()//返回当前分组的list} ...
java stream collec,Java stream的collect和Collector
weixin_42298412的博客
03-12 241
最近在使用Java8的新特性stream，因为LZ也在使用Spark，所以这种流式编程还是蛮顺手的，比以前的循环处理方便很多。stream基本用法网上有很多教程，这里就不在赘述了。这里LZ重点介绍stream的collect方法和其强大的工具类Collector。先看下接口中声名的collect方法： R collect(Collector super T, A, R> collector)...
java Collectors 分组求和
weixin_46692492的博客
04-24 2261
***//*** @param 集合元素类型* @param 中间结果容器* @param 最终结果类型*/// T代表流中元素的类型，A是中间处理临时保存类型，R代表返回结果的类型CollectorImpl(Supplier supplier, // 产生结果容器BiConsumer accumulator, // 累加器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值