Java8 Stream收集器collect操作

已于 2023-06-29 13:56:55 修改
阅读量1.1k 收藏 3
点赞数 1
分类专栏： Java系列 文章标签： java
于 2023-06-29 13:14:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_35410857/article/details/131452422
版权

收集器， 一种通用的、 从流生成复杂值的结构。 只要将它传给 collect 方法， 所有的流就都可以使用它了。
收集器可以做很多事情，例如：计数、分组、归并、求和等。

收集器汇总
序号方法含义
1Collectors.averageingInt
Collectors.averagingLong
Collectors.averagingDouble		平均值
2Collectors.collectingAndThen统计并转换
3Collectors.counting计数
4Collectors.groupingBy分组
5Collectors.mapping替换
6Collectors.maxBy
Collectors.minBy		最大值、最小值
7Collectors.partitioningBy按Boolean分组
8Collectors.reducing归并
9Collectors.summarizingInt
Collectors.summarizingLong
Collectors.summarizingDouble		获得统计结果对象
10Collectors.summingInt
Collectors.summingLong
Collectors.summingDouble		求和
11Collectors.toList将流转换成list
12Collectors.toSet将流转换成set
13Collectors.toCollection将流转换成Collection
14Collectors.toMap
Collectors.toConcurrentMap		将流转换成map

Collectors.averagingInt、Collectors.averagingLong、Collectors.averagingDouble：

统计Stream<T>流中， (根据)每个元素T得到的类型为int/long/double的数值的平均值。

/**
     * 统计Stream<T>流中, (根据)每个元素T得到的类型为int/long/double的数值的平均值。
     *
     * 注:统计结果为Double。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的caveragingLong方法，签名为:
     *       Collector<T, ?, Double> averagingInt(ToIntFunction<? super T> mapper)
     *
     * 注:Collectors的caveragingLong方法，签名为:
     *       Collector<T, ?, Double> averagingLong(ToLongFunction<? super T> mapper)
     *
     * 注:Collectors的caveragingLong方法，签名为:
     *       Collector<T, ?, Double> averagingDouble(ToDoubleFunction<? super T> mapper)
     *
     * 注:当前stream元素类型为T。
     *
     * 注:由于计算机二进制存数的问题，返回的double值可能存在误差。
     *
     * 建议:尽量少用此方法，如果非要用的话，建议用在那些对精度要求不高的场景下，且对结果进行舍入。
     */
    @Test
    public void test27_0() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三").age(18).workStartTimestamp(1L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(24).workStartTimestamp(2L).faceScore(89.2D).build(),
                Staff.builder().name("王五").age(45).workStartTimestamp(3L).faceScore(68.6D).build()
        );

        // Collectors.averagingInt进行统计
        Double averageOne = tmpList.parallelStream().collect(
                // -> 根据Int值统计出平均值Double的统计器
                Collectors.averagingInt(
                        x -> x == null ? 0 : x.getAge()
                )

        );
        // 输出: 29.0
        System.out.println(averageOne);

        // Collectors.averagingLong进行统计
        Double averageTwo = tmpList.parallelStream().collect(
                // -> 根据Long值统计出平均值Double的统计器
                Collectors.averagingLong(
                        x -> x == null ? 0L : x.getWorkStartTimestamp()
                )
        );
        // 输出: 2.0
        System.out.println(averageTwo);

        // Collectors.averagingDouble进行统计
        Double averageThree = tmpList.parallelStream().collect(
                // -> 根据Double值统计出平均值Double的统计器
                Collectors.averagingDouble(
                        x -> x == null ? 0D : x.getFaceScore()
                )
        );
        // 输出: 85.90000000000002
        // 注:由于计算机二进制存数的问题，返回的double值可能存在误差, 如:这里理
        //    论上应返回85.9, 但是实际上返回的是85.90000000000002
        System.out.println(averageThree);
    }

Collectors.collectingAndThen：

先按照Collectors对Stream<T>流中的元素进行统计(得到R), 再利用Function<R,RR>得到并返回RR。

/**
     * 先按照Collectors对Stream<T>流中的元素进行统计(得到R), 再利用Function<R,RR>得到并返回RR。
     * 即:对流的元素先Collector<T,A,R> downstream,再对得到的结果进行Function<R,RR> finisher，最后返回RR。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的collectingAndThen方法，签名为:
     *       Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream,
     *                                           Function<R,RR> finisher)
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_1() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三").age(18).workStartTimestamp(1L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(25).workStartTimestamp(2L).faceScore(89.2D).build(),
                Staff.builder().name("王五").age(40).workStartTimestamp(3L).faceScore(68.7D).build()
        );

        // 为便于理解，这里 先编写一个Function<R,RR> finisher
        Function<Set<Staff>, Integer> function = Set::size;

        // 先Collector<T,A,R> downstream,再Function<R,RR> finisher，最后返回RR。
        Integer size = tmpList.parallelStream().collect(
                Collectors.collectingAndThen(
                        Collectors.toSet(),
                        function
                )
        );
        // 输出: 3
        System.out.println(size);
    }

Collectors.counting：

对stream中的元素进行计数。

/**
     * 对stream中的元素进行计数。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的counting方法，签名为:
     *       Collector<T, ?, Long> counting()
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_2() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三").age(18).workStartTimestamp(1L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(25).workStartTimestamp(2L).faceScore(89.2D).build(),
                Staff.builder().name("王五").age(40).workStartTimestamp(3L).faceScore(68.7D).build()
        );
        @SuppressWarnings("all")
        // 对stream中的元素进行计数。 等价于Stream的count()方法。
        Long count = tmpList.parallelStream().collect(
                Collectors.counting()
        );
        // 输出: 3
        System.out.println(count);
    }

Collectors.groupingBy：

对stream中的元素进行分组。

用法一： 先通过classifier，计算每个元素对应的key，然后再通过Collectors的groupingBy方法，按key值分组，得到并返回Map<K, List<T>>。

/**
     * 对stream中的元素进行分组:
     *     先通过classifier，计算每个元素对应的key,然后再通过Collectors的
     *     groupingBy方法，按key值分组，得到并返回Map<K, List<T>>
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的重载groupingBy方法，(本次示例的方法的)签名为:
     *       Collector<T, ?, Map<K, List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
     *    追注:此方法内部调用的实际是groupingBy(classifier, HashMap::new, toList())方法
     *
     * 注:此方法返回的Map实现是非线程安全的，如果需要返回线程安全的Map实现，可使用(使用方式几乎一致):
     *         Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier)
     *
     * 注: 不论是串行stream，还是并行parallelStream，对于groupingBy(或groupingByConcurrent)本身来说，是线程安全的。
     *
     * 注:当前stream类型为T。
     *
     *
     */
    @Test
    public void test27_3() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三1").age(18).build(),
                Staff.builder().name("张三2").age(15).build(),
                Staff.builder().name("李四1").age(25).build(),
                Staff.builder().name("李四2").age(23).build(),
                Staff.builder().name("王五1").age(55).build(),
                Staff.builder().name("王五2").age(40).build()
        );

        // 为便于理解，这里 先编写一个Function<? super T, ? extends K> classifier
        // 这个classifier的作用是: 根据元素T，返回其对应的K, 然后Collectors.groupingBy会根据K，
        // 将stream中的元素按键值对分组为Map<K, List<T>
        Function<Staff, String> function = x -> x.getName() == null ? "" : x.getName().substring(0, 1);

        // 使用Collectors.groupingBy，按照(通过Function得到的)key进行分组，得到并返回Map<K, List<T>>
        Map<String, List<Staff>> resultMap = tmpList.parallelStream().collect(
                Collectors.groupingBy(function)
        );

        // 输出(为方便观察，本人简单整理了一下输出结果):
        // {
        //   张=[
        //       Staff(name=张三1, age=18, staffNo=null, faceScore=null, workStartTimestamp=null),
        //       Staff(name=张三2, age=15, staffNo=null, faceScore=null, workStartTimestamp=null)
        //      ],
        //
        //   王=[
        //       Staff(name=王五1, age=55, staffNo=null, faceScore=null, workStartTimestamp=null),
        //       Staff(name=王五2, age=40, staffNo=null, faceScore=null, workStartTimestamp=null)
        //      ],
        //
        //   李=[
        //       Staff(name=李四1, age=25, staffNo=null, faceScore=null, workStartTimestamp=null),
        //       Staff(name=李四2, age=23, staffNo=null, faceScore=null, workStartTimestamp=null)
        //      ]
        // }
        System.out.println(resultMap);
    }

用法二： 先通过classifier，计算每个元素对应的key，然后根据key进行分组，然后对每组的元素T进行downstream统计，得到每组的结果D， 最终返回Map<K, D>。

即：先通过classifier得到Map<K, List<T>>，再通过对每个List<T>进行downstream统计，最终得到Map<K, D>。

/**
     * 对stream中的元素进行分组:
     *     先通过classifier，计算每个元素对应的key,然后根据key进行分组，然后对每组的
     *     元素T进行downstream统计，得到每组的结果D， 最终返回Map<K, D>。
     *     即:先通过classifier得到Map<K, List<T>>，再通过
     *        对每个List<T>进行downstream统计，最终得到Map<K, D>。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的重载groupingBy方法，(本次示例的方法的)签名为:
     *       Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
     *                                             Collector<? super T, A, D> downstream)
     *    追注:此方法内部调用的实际是groupingBy(classifier, HashMap::new, downstream)方法
     *
     * 注:此方法返回的Map实现是非线程安全的，如果需要返回线程安全的Map实现，可使用(使用方式几乎一致):
     *         Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier,
     *                                                                   Collector<? super T, A, D> downstream)
     *
     * 注: 不论是串行stream，还是并行parallelStream，对于groupingBy(或groupingByConcurrent)本身来说，是线程安全的。
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_4() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三1").age(18).build(),
                Staff.builder().name("张三2").age(15).build(),
                Staff.builder().name("张三3").age(11).build(),
                Staff.builder().name("李四1").age(25).build(),
                Staff.builder().name("李四2").age(23).build(),
                Staff.builder().name("王五1").age(55).build(),
                Staff.builder().name("王五2").age(40).build()
        );

        // 为便于理解，这里 先编写一个Function<? super T, ? extends K> classifier
        Function<Staff, String> function = x -> x.getName() == null ? "" : x.getName().substring(0, 1);

        // 使用Collectors.groupingBy，按照(通过Function得到的)key进行分组并对各组元素进行统计，得到并返回Map<K, D>
        Map<String, Long> resultMap = tmpList.parallelStream().collect(
                Collectors.groupingBy(function, Collectors.counting())
        );

        // 输出: {张=3, 王=2, 李=2}
        System.out.println(resultMap);
    }

用法三： 先通过classifier，计算每个元素对应的key，然后根据key进行分组，然后对每组的元素T进行downstream统计，得到每组的结果D。最终返回Map<K, D>。Map<K, D>即对应Supplier<M> mapFactory中的M，换句话说，返回的Map容器由mapFactory进行提供。

即：先通过classifier得到Map<K, List<T>>，再通过对每个List<T>进行downstream统计，并将K和D放入由mapFactory提供的M中(即:mapFactory提供的Map中)，并进行返回。

/**
     * 对stream中的元素进行分组:
     *     先通过classifier，计算每个元素对应的key,然后根据key进行分组，然后对每组的
     *     元素T进行downstream统计，得到每组的结果D。最终返回Map<K, D>。Map<K, D>
     *     即对应Supplier<M> mapFactory中的M，换句话说:返回的Map容器由mapFactory进行提供。
     *     即:先通过classifier得到Map<K, List<T>>，再通过
     *        对每个List<T>进行downstream统计，并将K和D放入由mapFactory提供
     *        的M中(即:mapFactory提供的Map中)，并进行返回。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的重载groupingBy方法，(本次示例的方法的)签名为:
     *       Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
     *                                     Supplier<M> mapFactory,
     *                                     Collector<? super T, A, D> downstream)
     * 注:此方法返回的Map实现是非线程安全的，如果需要返回线程安全的Map实现，可使用(使用方式几乎一致):
     *         Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier,
     *                                                 Supplier<M> mapFactory,
     *                                                 Collector<? super T, A, D> downstream)
     *
     * 注: 不论是串行stream，还是并行parallelStream，对于groupingBy(或groupingByConcurrent)本身来说，是线程安全的。
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_5() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三1").age(18).build(),
                Staff.builder().name("张三2").age(15).build(),
                Staff.builder().name("张三3").age(11).build(),
                Staff.builder().name("李四1").age(25).build(),
                Staff.builder().name("李四2").age(23).build(),
                Staff.builder().name("王五1").age(55).build(),
                Staff.builder().name("王五2").age(40).build()
        );

        // 为便于理解，这里 先编写一个Function<? super T, ? extends K> classifier
        Function<Staff, String> function = x -> x.getName() == null ? "" : x.getName().substring(0, 1);


        //  Supplier<M> mapFactory
        Supplier<TreeMap<String, Long>> mapFactory = TreeMap::new;

        // 使用Collectors.groupingBy，按照(通过Function得到的)key进行分组并对各组元素进行统计，得到并返回Map<K, D>
        Map<String, Long> resultMap = tmpList.parallelStream().collect(
                Collectors.groupingBy(function, mapFactory, Collectors.counting())
        );

        // 输出: {张=3, 王=2, 李=2}
        System.out.println(resultMap);
    }

Collectors.joining：

字符串拼接。

用法一：对Stream<String>中的元素直接进行拼接。

/**
     * 对Stream<String>中的元素直接进行拼接。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的joining方法，签名为:
     *         Collector<CharSequence, ?, String> joining()
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_6() {
        // 数据准备
        List<String> tmpList = Lists.newArrayList("A","B","C","D","E");

        String resultStr = tmpList.parallelStream().collect(
                Collectors.joining()
        );

        // 输出: ABCDE
        System.out.println(resultStr);
    }

用法二：对Stream<String>中的元素以delimiter为分隔符进行拼接。

/**
     * 对Stream<String>中的元素以delimiter为分隔符进行拼接。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的joining方法，签名为:
     *         Collector<CharSequence, ?, String> joining(CharSequence delimiter)
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_7() {
        // 数据准备
        List<String> tmpList = Lists.newArrayList("A","B","C","D","E");

        String resultStr = tmpList.parallelStream().collect(
                Collectors.joining("-")
        );

        // 输出: A-B-C-D-E
        System.out.println(resultStr);
    }

用法三：以delimiter为分隔符，以prefix为前缀，以suffix为后缀，对Stream<String>中的元素进行拼接。

/**
     * 以delimiter为分隔符，以prefix为前缀，以suffix为后缀，对Stream<String>中的元素进行拼接。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的joining方法，签名为:
     *         Collector<CharSequence, ?, String> joining(CharSequence delimiter,
     *                                                    CharSequence prefix,
     *                                                    CharSequence suffix)
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_8() {
        // 数据准备
        List<String> tmpList = Lists.newArrayList("A","B","C","D","E");

        String resultStr = tmpList.parallelStream().collect(
                Collectors.joining("-", "[", "]")
        );

        // 输出: [A-B-C-D-E]
        System.out.println(resultStr);
    }

Collectors.mapping：

先以mapper将Stream<T>转换为Stream<U>，再用downstream对Stream<U>进行统计。

提示：collect(mapping())能做的事，.map().collect()都能做；我们一般都使用.map().collect()，而不使用collect(mapping())。

/**
     * 先以mapper将Stream<T>转换为Stream<U>，再用downstream对Stream<U>进行统计。
     *
     * 提示:collect(mapping())能做的事，.map().collect()都能做；我们一般都
     *     使用.map().collect()，而不使用collect(mapping())。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的mapping方法，签名为:
     *         Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper,
     *                                    Collector<? super U, A, R> downstream)
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_9() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三").age(18).workStartTimestamp(1L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(25).workStartTimestamp(2L).faceScore(89.2D).build(),
                Staff.builder().name("王五").age(40).workStartTimestamp(3L).faceScore(68.7D).build()
        );

        // 为便于理解，这里 先编写一个Function<? super T, ? extends U> mapper
        Function<Staff, String> function = Staff::getName;
        @SuppressWarnings("all")
        String resultStr = tmpList.parallelStream().collect(
                Collectors.mapping(
                        function,
                        Collectors.joining("&")
                )
        );
        // 输出: 张三&李四&王五
        System.out.println(resultStr);

        /// 以.map().collect()的方式来实现的话，是这样的:
        String resultStr2 =  tmpList.parallelStream().map(Staff::getName).collect(Collectors.joining("&"));
        // 输出: 张三&李四&王五
        System.out.println(resultStr2);
    }

Collectors.maxBy、Collectors.minBy：

根据比较器，筛选出Stream<T>中最大、最小的元素。

/**
     * 根据比较器，筛选出Stream<T>中最大、最小的元素。
     *
     * 注:推荐使用.max()、.min()的方式，而非.collect(Collectors.maxBy())、.collect(Collectors.minBy())
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的maxBy方法，签名为:
     *         Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)
     *
     * 注:Collectors的maxBy方法，签名为:
     *         Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator)
     *
     * 注:当前stream类型为T。
     */
    @Test
    @SuppressWarnings("all")
    public void test27_10() {
        // 数据准备
        List<Integer> tmpList = Lists.newArrayList(3, 5, 1, 7, 9);

        // 比较器准备
        Comparator<Integer> comparator = Comparator.comparingInt(x -> x);

        // -> 最大值
        // 等价于: tmpList.parallelStream().max(comparator)
        Optional<Integer> maxResult = tmpList.parallelStream().collect(
                Collectors.maxBy(comparator)
        );
        // 输出: 9
        maxResult.ifPresent(System.out::println);

        // -> 最小值
        // 等价于: tmpList.parallelStream().min(comparator)
        Optional<Integer> minResult = tmpList.parallelStream().collect(
                Collectors.minBy(comparator)
        );
        // 输出: 1
        minResult.ifPresent(System.out::println);
    }

Collectors.partitioningBy：

(按key为true或false进行)分组。

用法一： 将Stream中的元素，分为两组: predicate通过的分到key为true的组，否者分到key为false的组,最后得到并返回Map<Boolean, List<T>>>。

/**
     * 将Stream<T>中的元素，分为两组: predicate通过的分到key为true的组，否者分到key为false的组,
     * 最后得到并返回Map<Boolean, List<T>>>。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的partitioningBy方法，签名为:
     *         Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate)
     *    追注:此方法与groupingBy方法类似，也是分组。不过此方法是根据predicate将元素分为key为tru/false两组;
     *        而groupingBy是根据Function<? super T, ? extends K> classifier来进行的分组。
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_11() {
        // 数据准备
        List<Integer> tmpList = Lists.newArrayList(3, 5, 1, 7, 9);

        // 准备一个比较器
        Predicate<Integer> predicate = x -> x > 6;

        // -> 最大值
        Map<Boolean, List<Integer>> resultMap = tmpList.parallelStream().collect(
                Collectors.partitioningBy(predicate)
        );
        // 输出: {false=[3, 5, 1], true=[7, 9]}
        System.out.println(resultMap);
    }

用法二： 将Stream<T>中的元素，分为两组: predicate通过的分到key为true的组，否者分到key为false的组，然后通过downstream再对每组进行统计(得到统计结果D)，最后得到并返回Map<Boolean, D>。

/**
     * 将Stream<T>中的元素，分为两组: predicate通过的分到key为true的组，否者分到key为false的组,
     * 然后通过downstream再对每组进行统计(得到统计结果D)，最后得到并返回Map<Boolean, D>。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的partitioningBy方法，签名为:
     *         Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate,
     *                                                         Collector<? super T, A, D> downstream)
     *    追注:此方法与groupingBy方法类似,类比着进行理解即可。
     *
     * 注:当前stream类型为T。
     */
    @Test
    public void test27_12() {
        // 数据准备
        List<Integer> tmpList = Lists.newArrayList(3, 5, 1, 7, 9);

        // 准备一个比较器
        Predicate<Integer> predicate = x -> x > 6;

        // -> 最大值
        Map<Boolean, Long> resultMap = tmpList.parallelStream().collect(
                Collectors.partitioningBy(
                        predicate,
                        Collectors.counting()
                )
        );
        // 输出: {false=3, true=2}
        System.out.println(resultMap);
    }

Collectors.reducing：

对Stream中的元素进行归并。

提示： 串行流下的reduce与并行流下的reduce可能结果不一样，如果不太熟悉的话，建议使用stream的reduce()，而不使用.stream().collect(Collectors.reducing())。

/**
     * 对Stream<T>中的元素进行归并。
     * 提示:串行流下的reduce与并行流下的reduce可能结果不一样，如果不太熟悉的话，建议
     *      使用stream的reduce()，而不使用.stream().collect(Collectors.reducing())。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的reducing方法，签名为:
     *        Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)
     *
     * 注:当前stream类型为T。
     *
     * 声明:在stream的collect()方法内部进行reduce的，总共有下述三种方法
     *      Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)
     *      Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)
     *      Collector<T,?,U> reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op),
     *      此这里只示例第一种。
     */
    @Test
    public void test27_13() {
        // 数据准备
        List<Integer> tmpList = Lists.newArrayList(3, 5, 1, 7, 9);

        BinaryOperator<Integer> binaryOperator = Integer::sum;
        // -> 进行归并
        @SuppressWarnings("all")
        Optional<Integer> result = tmpList.stream().collect(
                Collectors.reducing(binaryOperator)
        );
        // 输出: 25
        result.ifPresent(System.out::println);
    }

Collectors.summarizingInt、Collectors.summarizingLong、Collectors.summarizingDouble：

对Stream<T>中的元素T“对应”的int/long/double值进行统计，并获得一个统计对象；通过此对象可以获得具体的统计信息(如：最大值、最小值、平均值、总和、数量)。

/**
     * 对Stream<T>中的元素T“对应”的int/long/double值进行统计，并获得一个统计对象；
     * 通过此对象可以获得具体的统计信息(如:最大值、最小值、平均值、总和、数量)。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的summarizingInt方法，签名为:
     *        Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
     *
     * 注:Collectors的summarizingLong方法，签名为:
     *        Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
     *
     * 注:Collectors的summarizingDouble方法，签名为:
     *        Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_14() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );

        /// -> summarizingInt示例
        // 编写mapper，使用此mapper,能根据Stream<T>中的元素T，获取到对应的int值
        ToIntFunction<Staff> intMapper = Staff::getAge;
        // 采集数据，获得统计信息 对象
        IntSummaryStatistics intResult = tmpList.parallelStream().collect(
                Collectors.summarizingInt(intMapper)
        );
        // 输出: IntSummaryStatistics{count=3, sum=87, min=18, average=29.000000, max=45}
        System.out.println(intResult);

        /// -> summarizingLong示例
        // 编写mapper，使用此mapper,能根据Stream<T>中的元素T，获取到对应的int值
        ToLongFunction<Staff> longMapper = Staff::getWorkStartTimestamp;
        // 采集数据，获得统计信息 对象
        LongSummaryStatistics longResult = tmpList.parallelStream().collect(
                Collectors.summarizingLong(longMapper)
        );
        // 输出: LongSummaryStatistics{count=3, sum=1368, min=123, average=456.000000, max=789}
        System.out.println(longResult);

        /// -> summarizingDouble示例
        // 编写mapper，使用此mapper,能根据Stream<T>中的元素T，获取到对应的double值
        ToDoubleFunction<Staff> doubleMapper = Staff::getFaceScore;
        // 采集数据，获得统计信息 对象
        DoubleSummaryStatistics doubleResult = tmpList.parallelStream().collect(
                Collectors.summarizingDouble(doubleMapper)
        );
        // 输出: DoubleSummaryStatistics{count=3, sum=199.800000, min=33.300000, average=66.600000, max=99.900000}
        System.out.println(doubleResult);
    }

Collectors.summingInt、Collectors.summingLong、Collectors.summingDouble：

求和。

提示：建议使用.mapToInt().sum()，而不使用.collect(Collectors.summingInt())；建议使用.mapToLong().sum()，而不使用.collect(Collectors.summingLong())；建议使用.mapToDouble().sum()，而不使用.collect(Collectors.summingDouble())。

/**
     * 对Stream<T>中的元素T“对应”的int/long/double值进行求和。
     *
     * 建议使用.mapToInt().sum()，而不使用.collect(Collectors.summingInt())
     * 建议使用.mapToLong().sum()，而不使用.collect(Collectors.summingLong())
     * 建议使用.mapToDouble().sum()，而不使用.collect(Collectors.summingDouble())
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的summarizingInt方法，签名为:
     *        Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper)
     *
     * 注:Collectors的summarizingLong方法，签名为:
     *        Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
     *
     * 注:Collectors的summarizingDouble方法，签名为:
     *        Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    @SuppressWarnings("all")
    public void test27_15() {
        // 数据准备
        List<Staff> tmpList = Lists.newArrayList(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );

        /// -> summingInt示例
        // 编写mapper，使用此mapper,能根据Stream<T>中的元素T，获取到对应的int值
        ToIntFunction<Staff> intMapper = Staff::getAge;
        // Integer求和
        Integer intResult = tmpList.parallelStream().collect(
                Collectors.summingInt(intMapper)
        );
        // 输出: 87
        System.out.println(intResult);

        /// -> summingLong示例
        // 编写mapper，使用此mapper,能根据Stream<T>中的元素T，获取到对应的int值
        ToLongFunction<Staff> longMapper = Staff::getWorkStartTimestamp;
        // Long求和
        Long longResult = tmpList.parallelStream().collect(
                Collectors.summingLong(longMapper)
        );
        // 输出: 1368
        System.out.println(longResult);

        /// -> summingDouble示例
        // 编写mapper，使用此mapper,能根据Stream<T>中的元素T，获取到对应的double值
        ToDoubleFunction<Staff> doubleMapper = Staff::getFaceScore;
        //  Double求和
        Double doubleResult = tmpList.parallelStream().collect(
                Collectors.summingDouble(doubleMapper)
        );
        // 输出: 199.8
        System.out.println(doubleResult);
    }

Collectors.toList：

将Stream<T>转换为一个集合List<T>。

提示：实际上转换成的是ArrayList<T>。

/**
     * 将Stream<T>转换为一个集合List<T>。
     * 注:实际上转换成的是ArrayList<T>
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的toList方法，签名为:
     *        Collector<T, ?, List<T>> toList()
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_16() {
        // 数据准备
        Stream<Staff> s = Stream.of(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );
        // 将String<T>转换为集合List<T>
        List<Staff> list = s.parallel().collect(
                Collectors.toList()
        );
        // 输出(为方便观察，本人简单整理了一下输出结果):
        // [
        //  Staff(name=张三, age=18, staffNo=null, faceScore=99.9, workStartTimestamp=123),
        //  Staff(name=李四, age=45, staffNo=null, faceScore=66.6, workStartTimestamp=456),
        //  Staff(name=王五, age=24, staffNo=null, faceScore=33.3, workStartTimestamp=789)
        // ]
        System.out.println(list);
    }

Collectors.toSet：

将Stream<T>转换为一个集合Set<T>。

提示：实际上转换成的是HashSet<T>。

/**
     * 将Stream<T>转换为一个集合Set<T>。
     * 注:实际上转换成的是HashSet<T>。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的toSet方法，签名为:
     *        Collector<T, ?, Set<T>> toSet()
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_17() {
        // 数据准备
        Stream<Staff> s = Stream.of(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );
        // 将String<T>转换为集合List<T>
        Set<Staff> set = s.parallel().collect(
                Collectors.toSet()
        );
        // 输出(为方便观察，本人简单整理了一下输出结果):
        // [
        //  Staff(name=张三, age=18, staffNo=null, faceScore=99.9, workStartTimestamp=123),
        //  Staff(name=李四, age=45, staffNo=null, faceScore=66.6, workStartTimestamp=456),
        //  Staff(name=王五, age=24, staffNo=null, faceScore=33.3, workStartTimestamp=789)
        // ]
        System.out.println(set);
    }

Collectors.toCollection：

将Stream转换为一个(自定义类型的)集合。

/**
     * 将Stream<T>转换为一个(自定义类型的)集合。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的toCollection方法，签名为:
     *        Collector<T, ?, C> toCollection(Supplier<C> collectionFactory)
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_18() {
        // 数据准备
        Stream<Staff> s = Stream.of(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );

        // 先实现Supplier<C>, Supplier<C>会提供一种集合容器。
        Supplier<LinkedList<Staff>> collectionFactory = LinkedList::new;

        // 将String<T>转换为集合LinkedList<T>
        LinkedList<Staff> linkedList = s.parallel().collect(
                Collectors.toCollection(collectionFactory)
        );
        // 输出(为方便观察，本人简单整理了一下输出结果):
        // [
        //  Staff(name=张三, age=18, staffNo=null, faceScore=99.9, workStartTimestamp=123),
        //  Staff(name=李四, age=45, staffNo=null, faceScore=66.6, workStartTimestamp=456),
        //  Staff(name=王五, age=24, staffNo=null, faceScore=33.3, workStartTimestamp=789)
        // ]
        System.out.println(linkedList);
    }

Collectors.toMap、Collectors.toConcurrentMap：

将流转换为Map(或ConcurrentMap)。

特别注意：筛选出来后(，调用Map#merge方法之前，需保证)value值不能为null，否者会报NPE。可详见源码java.util.Map(或其对应子类)的merge方法。

用法一： 将Stream<T>转换为一个Map， 在转换时若发现重复的key，那么会抛出异常。

提示：这里示例的是toMap方法(转换为线程非安全的Map),对应的(转换为线程 安全的ConcurrentMap的)toConcurrentMap方法用法几乎是一样的。

/**
     * 将Stream<T>转换为一个Map, 在转换时若发现重复的key,那么会抛出异常。
     *
     * 提示:这里示例的是toMap方法(转换为线程非安全的Map),对应的(转换为线程
     *      安全的ConcurrentMap的)toConcurrentMap方法用法几乎是一样的。
     *
     * 特别注意:筛选出来后(，调用Map#merge方法之前，需保证)value值不能为null,否者会报NPE。可详见源码java.util.Map(或其对应子类)的merge方法。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的toMap方法，签名为:
     *        Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
     *        追注:此方式的toMap,要求key不能有重复的，否者会出错
     *            java.lang.IllegalStateException: java.lang.IllegalStateException: Duplicate key...
     *        追注:此方法内部调用的其实是:toMap(keyMapper, valueMapper, throwingMerger(), HashMap::new);
     *
     * 注:Collectors的toConcurrentMap方法，签名为:
     *        Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
     *        追注:用法与本示例几乎一样，不过toConcurrentMap是线程安全的。
     *        追注:此方式的toMap,要求key不能有重复的，否者会出错
     *            java.lang.IllegalStateException: java.lang.IllegalStateException: Duplicate key...
     *        追注:此方法内部调用的其实是:toConcurrentMap(keyMapper, valueMapper, throwingMerger(), ConcurrentHashMap::new)
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_19() {
        // 数据准备
        Stream<Staff> s = Stream.of(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );

        // 编写一个keyMapper，用于 根据元素T获取对应的key
        Function<Staff, String> keyMapper = Staff::getName;

        // 编写一个valueMapper，用于 根据元素T获取对应的value
        Function<Staff, Integer> valueMapper = Staff::getAge;

        // 将Stream<T>转换为Map
        Map<String, Integer> resultMap = s.collect(
                Collectors.toMap(keyMapper, valueMapper)
        );

        // 输出: {李四=45, 张三=18, 王五=24}
        System.out.println(resultMap);
    }

用法二： 将Stream<T>转换为一个Map，在转换时若发现重复的key，那么会根据mergeFunction来决定该key的value是多少。

提示：这里示例的是toMap方法(转换为线程非安全的Map),对应的(转换为线程安全的ConcurrentMap的)toConcurrentMap方法用法几乎是一样的。

/**
     * 将Stream<T>转换为一个Map, 在转换时若发现重复的key,那么会根据mergeFunction来决定该key的value是多少。
     *
     * 提示:这里示例的是toMap方法(转换为线程非安全的Map),对应的(转换为线程
     *      安全的ConcurrentMap的)toConcurrentMap方法用法几乎是一样的。
     *
     * 特别注意:筛选出来后(，调用Map#merge方法之前，需保证)value值不能为null,否者会报NPE。可详见源码java.util.Map(或其对应子类)的merge方法。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的toMap方法，签名为:
     *        Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
     *        追注:此方法内部调用的其实是:toMap(keyMapper, valueMapper, mergeFunction, HashMap::new)
     *
     * 注:Collectors的toConcurrentMap方法，签名为:
     *        Collector<T,?,ConcurrentMap<K,U>> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
     *        追注:用法与本示例几乎一样，不过toConcurrentMap是线程安全的。
     *        追注:此方法内部调用的其实是:toConcurrentMap(keyMapper, valueMapper, mergeFunction, ConcurrentHashMap::new)
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_20() {
        // 数据准备
        Stream<Staff> s = Stream.of(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("张三").age(100).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );

        // 编写一个keyMapper，用于 根据元素T获取对应的key
        Function<Staff, String> keyMapper = Staff::getName;

        // 编写一个valueMapper，用于 根据元素T获取对应的value
        Function<Staff, Staff> valueMapper = Function.identity();

        // 编写一个mergeFunction，用于 处理 key冲突时的逻辑
        BinaryOperator<Staff> mergeFunction = (Staff preStaff, Staff nextValue) -> {
            // 输出: oldStaff的name是[张三]， age是[18]
            System.err.println("preStaff的name是[" + preStaff.getName() + "]， age是[" + preStaff.getAge() + "]");
            // 输出: oldStaff的name是[张三]， age是[100]
            System.err.println("nextValue的name是[" + nextValue.getName() + "]， age是[" + nextValue.getAge() + "]");
            return nextValue;
        };

        // 将Stream<T>转换为Map
        Map<String, Staff> resultMap = s.collect(
                Collectors.toMap(keyMapper, valueMapper, mergeFunction)
        );

        // 输出(为方便观察，本人简单整理了一下输出结果):
        // {
        //  李四=Staff(name=李四, age=45, staffNo=null, faceScore=66.6, workStartTimestamp=456),
        //  张三=Staff(name=张三, age=100, staffNo=null, faceScore=99.9, workStartTimestamp=123),
        //  王五=Staff(name=王五, age=24, staffNo=null, faceScore=33.3, workStartTimestamp=789)
        // }
        System.out.println(resultMap);
    }

用法三： 将Stream<T>转换为一个(由mapSupplier定义提供的)Map，在转换时若发现重复的key，那么会根据mergeFunction来决定该key的value是多少。

提示：这里示例的是toMap方法(转换为线程非安全的Map),对应的(转换为线程安全的ConcurrentMap的)toConcurrentMap方法用法几乎是一样的。

/**
     * 将Stream<T>转换为一个(由mapSupplier定义提供的)Map, 在转换时若发现重复的key,
     * 那么会根据mergeFunction来决定该key的value是多少。
     *
     * 提示:这里示例的是toMap方法(转换为线程非安全的Map),对应的(转换为线程
     *      安全的ConcurrentMap的)toConcurrentMap方法用法几乎是一样的。
     *
     * 特别注意:筛选出来后(，调用Map#merge方法之前，需保证)value值不能为null,否者会报NPE。可详见源码java.util.Map(或其对应子类)的merge方法。
     *
     * 注:Stream的collect方法，签名为:
     *       <R, A> R collect(Collector<? super T, A, R> collector)
     *
     * 注:Collectors的toMap方法，签名为:
     *        Collector<T,?,M> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
     *
     * 注:Collectors的toConcurrentMap方法，签名为:
     *        Collector<T,?,M> toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M> mapSupplier)
     *        追注:用法与本示例几乎一样，不过toConcurrentMap是线程安全的。
     *
     * 注:当前stream类型为T。
     *
     */
    @Test
    public void test27_21() {
        // 数据准备
        Stream<Staff> s = Stream.of(
                Staff.builder().name("张三").age(18).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("张三").age(100).workStartTimestamp(123L).faceScore(99.9D).build(),
                Staff.builder().name("李四").age(45).workStartTimestamp(456L).faceScore(66.6D).build(),
                Staff.builder().name("王五").age(24).workStartTimestamp(789L).faceScore(33.3D).build()
        );

        // 编写一个keyMapper，用于 根据元素T获取对应的key
        Function<Staff, String> keyMapper = Staff::getName;

        // 编写一个valueMapper，用于 根据元素T获取对应的value
        Function<Staff, Integer> valueMapper = Staff::getAge;

        // 编写一个mergeFunction，用于 处理 key冲突时的逻辑
        BinaryOperator<Integer> mergeFunction = (Integer preValue, Integer nextValue) -> {
            // 输出: preValue是: 18
            System.err.println("preValue是: " + preValue);
            // 输出: nextValue是: 100
            System.err.println("nextValue是: " + nextValue);
            return nextValue;
        };

        // Map容器提供者。 .collect(Collectors.toMap())返回的Map, 由此mapSupplier进行提供。
        Supplier<LinkedHashMap<String, Integer>> mapSupplier = LinkedHashMap::new;

        // 将Stream<T>转换为Map
        LinkedHashMap<String, Integer> resultMap = s.collect(
                Collectors.toMap(keyMapper, valueMapper, mergeFunction, mapSupplier)
        );

        // 输出: {张三=100, 李四=45, 王五=24}
        System.out.println(resultMap);
    }

老猫喜欢今日爬山
关注
专栏目录
Java 8 Stream API深度解读：全方位探索collect()方法及其应用实践
java专栏
04-19 902
对于更复杂的收集逻辑，可以自定义Collector接口的实现。supplier()：提供一个用于存放结果的容器（如空列表或空映射）。：定义如何将流元素添加到容器中。combiner()：当流并行处理时，定义如何合并两个部分结果容器。finisher()（可选）：对容器进行最终处理，得到最终结果。Java378 // 自定义收集器，收集首字母并保持顺序15 )16 );1720 }21}用于创建自定义收集器，传入SupplierCombiner以及可选的Finisher。
JAVA 自定义解析stream_Java 8之自定义Stream收集器
weixin_33794626的博客
03-05 869
声明：本篇文章除部分引用外，均为原创内容，如有雷同纯属巧合，引用转载请附上原文链接与声明本文链接：注：阅读本篇文章需掌握java集合基础知识、Stream基本语法与使用、函数式接口、lambda表达式、泛型知识、lombok插件使用、guava基础集合工具使用、java8双冒号的使用；请先掌握上述知识再行阅读本篇文章。若有错误，欢迎友好纠正，谢谢。参考引用文章大纲Stream基础收集功能演示Str...
详解Java8 Collect收集Stream的方法
08-27
主要介绍了Java8-Collect收集Stream的方法，提到了收集器的作用，连接收集器的方法,需要的朋友可以参考下
collect() java_java流stream中的collect()方法详解
weixin_39830387的博客
02-12 2040
public class StreamTest {/*** stream.collect() 的本质由三个参数构成,* 1. Supplier 生产者, 返回最终结果* 2. BiConsumer accumulator 累加器* 第一个参数是要返回的集合, 第二个参数是遍历过程中的每个元素,* 将流中每个被遍历的元素添加到集合中* 3. BiConsumer combiner 合并器, 在有并行...
java Stream collect()使用
最新发布
qq_35175478的博客
08-20 302
【代码】java Stream collect()使用。
Stream流中collect方法
李长渊的博客
05-07 1万+
Stream流中collect方法
Java8 Stream流中的 collect() 方法，远比你想象中的强大
weixin_44421461的博客
08-01 5525
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析...
Java8-Stream collect
lf_haven的博客
08-31 501
Java8-Stream collect
Java8 Stream Collectors收集器使用方法解析
08-18
Java8 Stream Collectors收集器是Java8中Stream API的一种重要组件， Collectors是 Stream API 中的收集器接口，提供了许多实用的方法来处理Stream流数据。以下是Java8 Stream Collectors收集器使用方法解析的详细...
guava-stream:用于 Guava 不可变集合的 Java 8 Stream API 收集器
06-23
用于 Guava 不可变集合的 Java 8 Stream API 收集器 在Java 8个流API，你可以收集你的要素Stream采用的的多种方法之一java.util.Collectors类。 要收集java.util.List的元素，您可以这样做： list . stream() . ...
Java 8 特性 -- stream接口 终端collect
雷儿响叮当
06-28 154
public class TestJava8 { public static List<Emp> list = new ArrayList<>(); static { list.add(new Emp("上海", "小名", 17)); list.add(new Emp("北京", "小红", 18)); list.add(new Emp("深圳", "小蓝...
java Stream collect操作
X_W_T的博客
01-22 606
Collectors中的方法使用averaging 求平均值collectionAndThencountinggroupingBypartitioningByjoiningmappingmaxBY和minByreducingsummarizingsumming 数据集合 ArrayList<Person> list = new ArrayList<>(10); list.add(new Person().setId(0).setAge(10).setName("a")); list.
Java8新特性之Stream--collect方法
qq_38530648的博客
03-01 7774
collect方法 收集(collect) collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。 collect主要依赖java.util.stream.Collectors类内置的静态方法。 归集(toList/toSet/toMap) 因为流不存储数据，那么在流中的数据完成处理后，需要将流中的数据重新归集到新的集合里。 toList、toSet和toMap比较常用，另外还有toCollection、toCon
Java函数式编程Stream.collect()方法使用小结
热门推荐
weixin_44729970的博客
11-23 2万+
steam():把一个源数据，可以是集合，数组，I/O channel， 产生器generator 等，转化成流。 Collectors(): 类实现了很多归约操作，例如将流转换成集合和聚合元素。通过stream().collect()方法可简单获得我们所需要的数据结构。 先创建一个prodList的集合数据 @Data public class Product { private Long id; private Integer num; private BigDecimal pr
讲透JAVA Stream的collect用法与原理，远比你想象的更强大
是Vzn呀
07-18 2710
前面我们演示了很多Collectors工具类中提供的收集器的用法，上一节中列出来的Collectors提供的常用收集器，也可以覆盖大部分场景的开发诉求了。但也许在项目中，我们会遇到一些定制化的场景，现有的收集器无法满足我们的诉求，这个时候，我们也可以自己来实现定制化的收集器。我们知道，所谓的收集器，其实就是一个Collector接口的具体实现类。所以如果想要定制自己的收集器，首先要先了解Collector接口到底有哪些方法需要我们去实现，以及各个方法的作用与用途。当我们新建一个5个接口接口名称。...
Java8之Stream-强大的collect操作
BASK2312的博客
11-23 832
到此对于collect的操作应该就很清晰了,希望通过这些例子能掌握核心,也就是Collector接口中那几个函数的作用,希望对你有帮助.
Stream类的collect方法
kanpiaoxue的专栏
02-28 371
Stream类的collect方法 参考： https://www.jianshu.com/p/ccbb42ad9551   Collectors.toSet()：转换成set集合。 Collectors.toCollection(TreeSet::new)：转换成特定的set集合。 TreeSet&lt;Integer&gt; collect2 = Stream.of(1,...
java stream collect方法详解
xieqj_0511的博客
06-02 1570
jdk 1.8版本中stream的collect方法 <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); stream.collect() 的本质由三个参数构成, Supplier 新建对象, 用来返回的最终结果 BiCon
JAVA Stream的collect用法与原理
秃头的博客
11-12 2390
toList toSet toCollection toMap counting summingInt averagingInt joining maxBy minBy groupingBy partitioningBy collectingAndThen mapping
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值