5.Stream流的终结方法中的收集方法collect超详解

原创 已于 2025-03-25 12:55:39 修改 · 1.1k 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #stream流

于 2025-03-09 14:05:31 首次发布

一.收集方法collect方法概述：

  • 收集方法collect可以收集流中的数据，大多放到单列集合和双列集合中（单列集合包括List集合、Set集合，双列集合包括Map集合）。

  • 注：双列集合Map的键不能重复，值可以重复，因此使用collect方法将数据收集到Map集合中一定要保证键不重复，如果键重复了打印Map集合等操作会报错

二.stream流里的工具类Collectors：

1.工具类Collectors里的静态方法toList：该方法用于把流里的数据全部收集到单列集合List中

stream流里有一个工具类Collectors，工具类Collectors里有一个静态方法toList，toList方法的底层会帮我们创建一个ArrayList集合，然后把stream流里面的所有数据都收集到单列集合List中（ArrayList集合属于单列集合List的实现类），toList方法常和stream流里的collect方法结合使用：

2.工具类Collectors里的静态方法toSet：该方法用于把流里的数据全部收集到单列集合Set中

stream流里有一个工具类Collectors，工具类Collectors里有一个静态方法toSet，toSet方法的底层会帮我们创建一个HashSet集合，然后把stream流里面的所有数据都收集到单列集合Set中（HashSet集合属于单列集合Set的实现类），toSet方法常和stream流里的collect方法结合使用：

3.注意事项：流里的数据分别收集到List集合中和Set集合中的区别

package com.itheima.a02test;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
​
public class Test2 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"张无忌-男-15","张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-20",
                "张三丰-男-100","张翠山-男-40","张良-男-35","王二麻子-男-37","谢广坤-男-41");
        /*list集合中的数据的格式为姓名-性别-年龄*/
​
        //3.过滤元素并收集
        List<String> newList = list.stream()
                .filter(s -> "男".equals(s.split("-")[1])) //过滤不符合要求的数据，s此时代表stream流中的每一个数据即list集合中的每一个元素
                .collect(Collectors.toList());//收集数据
​
​
        //4.打印newList集合
        System.out.println(newList);
        //运行结果为[张无忌-男-15, 张无忌-男-15, 张强-男-20, 张三丰-男-100, 张翠山-男-40, 张良-男-35, 王二麻子-男-37, 谢广坤-男-41]
    }
}
​
package com.itheima.a02test;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;
import java.util.stream.Collectors;
​
public class Test3 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list, "张无忌-男-15", "张无忌-男-15","周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
        /*list集合中的数据的格式为姓名-性别-年龄*/
​
        //3.过滤元素并收集
        Set<String> newList = list.stream()
                .filter(s -> "男".equals(s.split("-")[1])) //s此时代表stream流中的每一个数据即list集合中的每一个元素
                .collect(Collectors.toSet());
​
        //4.打印newList集合
        System.out.println(newList);
        //运行结果为[张强-男-20, 张良-男-35, 张三丰-男-100, 张无忌-男-15, 谢广坤-男-41, 张翠山-男-40, 王二麻子-男-37]
    }
}

​

通过上述两段代码可以看出，分别收集到单列集合List中和单列集合Set中，最终打印的结果会有所不同

->收集到List集合中，会保证元素的顺序不变，而且元素可以重复（因为List集合添加元素的特点是有序、可重复、有索引）

->收集到Set集合中，元素的顺序可能会被打乱，而且元素不能重复即系统会自动去重（因为Set集合添加元素的特点是无序、不重复、无索引）

4.工具类Collectors里的静态方法toMap：该方法用于把流里的数据全部收集到双列集合Map中

stream流里有一个工具类Collectors，工具类Collectors里有一个静态方法toMap且只有两个形参，该toMap方法的底层会帮我们创建一个HashMap集合，然后把stream流里面的所有数据都收集到双列集合Map中（HashMap集合属于双列集合Map的实现类），该toMap方法常和stream流里的collect方法结合使用：

对于只有两个形参的toMap方法，该toMap方法的两个形参都为函数式接口Function，该函数式接口Function有两个泛型，第一个泛型表示流里面的数据的类型，第二个泛型是要收集到Map集合中的数据的类型；

对于toMap方法的两个形参：

第一个形参Function接口用于指定键的生成规则：

  • 该Function接口有两个泛型，第一个泛型表示流中每一个数据的类型；第二个泛型表示生成的Map集合中键的数据类型

  • 创建函数式接口Function类后需要重写里面的抽象方法apply，方法apply的形参依次表示流里面的每一个数据，apply方法的方法体就是生成键的代码（这个键是最终的Map集合里的），apply方法的返回值就是返回已经生成的键

  • 注：Function接口的第一个泛型类型和apply方法的形参类型对应，Function接口的第二个泛型类型和apply方法的返回值类型对应

第二个形参Function接口用于指定值的生成规则：

  • 该Function接口有两个泛型，第一个泛型表示流中每一个数据的类型；第二个泛型表示生成的Map集合中值的数据类型

  • 创建函数式接口Function类后需要重写里面的抽象方法apply，方法apply的形参依次表示流里面的每一个数据，apply方法的方法体就是生成值的代码（这个值是最终的Map集合里的），apply方法的返回值就是返回已经生成的值

  • 注：Function接口的第一个泛型类型和apply方法的形参类型对应，Function接口的第二个泛型类型和apply方法的返回值类型对应

三.实例：

1.collect方法收集流中的数据，放到单列集合List中：

需求：

把所有的男性收集起来。

解法一：
package com.itheima.a01mystream;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;
​
public class StreamDemo10 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-20",
                "张三丰-男-100","张翠山-男-40","张良-男-35","王二麻子-男-37","谢广坤-男-41");
        /*list集合中的数据的格式为姓名-性别-年龄*/
​
        //3.过滤元素并收集
        List<String> newList = list.stream().filter(new Predicate<String>() { /*list.stream()获取stream流,调用filter方法用于过滤数据*/
            @Override
            public boolean test(String s) { //s此时代表stream流中的每一个数据即list集合中的每一个元素
                String[] result = s.split("-");
                /*使用-切割list集合中的每一个元素后，每一个元素会放入数组中，
                  此时数组的0索引为姓名，1索引为性别，2索引为年龄*/
                if (result[1].equals("男")) return true; //返回true代表把result数组中1索引上是男性的数据留下，其余过滤掉
                return false; //此时返回false，代表把result数组中1索引上不是男性的数据过滤掉
            }
        }).collect(Collectors.toList());
​
        //4.打印newList集合
        System.out.println(newList);
    }
}
​

解法二：lambda表达式简化后
package com.itheima.a02test;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
​
public class Test2 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list=new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list,"张无忌-男-15","周芷若-女-14","赵敏-女-13","张强-男-20",
                "张三丰-男-100","张翠山-男-40","张良-男-35","王二麻子-男-37","谢广坤-男-41");
        /*list集合中的数据的格式为姓名-性别-年龄*/
​
        //3.过滤
        /* "男".equals(s.split("-")[1])和
           s.split("-")[1].equals("男")都可以，
           但通常的习惯是使用确定的数据调用方法与不确定的数据进行操作，
           所以"男".equals(s.split("-")[1])更好一些，
           因为确定的数据不可能是null，不确定的数据可能是null，
           如果不确定的数据为null，并且不确定的数据调用方法就会出现空指针异常，
           而确定的数据不可能为null，确定的数据调用方法不会出现空指针异常  */
        List<String> newList = list.stream()
                .filter(s -> "男".equals(s.split("-")[1])) //过滤不符合要求的数据
                .collect(Collectors.toList());//收集数据
        /*Collectors是stream流里的工具类，
          Collectors里有一个静态方法toList，
          toList方法的底层会帮我们创建一个ArrayList集合，
          然后把流里面的数据收集到该ArrayList集合中*/
​
        //4.打印newList集合
        System.out.println(newList);
    }
}

​

2.collect方法收集流中的数据，放到单列集合Set中：

需求：

把所有的男性收集起来。

解法：
package com.itheima.a02test;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.Set;
import java.util.stream.Collectors;
​
public class Test3 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list, "张无忌-男-15", "张无忌-男-15","周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
        /*list集合中的数据的格式为姓名-性别-年龄*/
​
        //3.过滤元素并收集
        Set<String> newList = list.stream()
                .filter(s -> "男".equals(s.split("-")[1])) //s此时代表stream流中的每一个数据即list集合中的每一个元素，虽然list集合属于ArrayList类，但list集合里的数据是可以收集到Set类中的，因为这里强调的是数据，和类无关
                .collect(Collectors.toSet());
​
        //4.打印newList集合
        System.out.println(newList);
        //运行结果为[张强-男-20, 张良-男-35, 张三丰-男-100, 张无忌-男-15, 谢广坤-男-41, 张翠山-男-40, 王二麻子-男-37]
    }
}
​

3.collect方法收集流中的数据，放到双列集合Map中：

收集到Map集合中首先要规定谁作为键，谁作为值，因为Map集合是双列集合

需求：

把所有的男性收集起来，其中键：姓名（姓名是字符串型即String型），值：年龄（年龄是整型，要用泛型，所以可以用Integer型），性别就不需要存了，因为只有男性的数据会被收集起来，意味着收集起来的数据一定是男性，此时性别已知，就没必要再收集了

解法：
package com.itheima.a02test;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
​
public class Test4 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
​
        //3.过滤元素并收集
        Map<String, Integer> map = list.stream().filter(s -> "男".equals(s.split("-")[1])) //意味着只把性别为男的留下
                /*
                 *   toMap方法：第一个形参表示键的生成规则
                 *             第二个形参表示值的生成规则
                 *
                 * toMap方法的第一个形参Function接口有两个泛型：
                 *           第一个泛型：表示流中每一个数据的类型
                 *           第二个泛型：表示生成的Map集合中键的数据类型
                 *           创建Function接口的类后就需要重写Function接口里的抽象方法apply：
                 *              apply方法的形参：依次表示流里面的每一个数据
                 *              apply方法的方法体：生成键的代码（这个键是最终的Map集合里的）
                 *              apply方法的返回值：返回已经生成的键
                 *
                 * toMap方法的第二个形参Function接口有两个泛型：
                 *           第一个泛型：表示流中每一个数据的类型
                 *           第二个泛型：表示生成的Map集合中值的数据类型
                 *           创建Function接口的类后就需要重写Function接口里的抽象方法apply：
                 *              apply方法的形参：依次表示流里面的每一个数据
                 *              apply方法的方法体：生成值的代码（这个值是最终的Map集合里的）
                 *              apply方法的返回值：返回已经生成的值
                 *
                 *
                 * */
                .collect(Collectors.toMap(new Function<String, String>() {
                                              /*toMap的第一个形参表示键的生成规则，此时键是姓名，姓名是字符串型，所以第一个形参Function接口的第二个泛型是String型*/
                                              @Override
                                              public String apply(String s) {
                                                  //s此时代表stream流中的每一个数据即集合中的每一个元素，如张无忌-男-15，被-切割后得到的数组中0索引是姓名，1索引是性别，2索引是年龄
                                                  String[] result = s.split("-");
                                                  //此时result的0索引表示姓名
                                                  String name = result[0];
                                                  return name;
                                              }
                                          },
                        new Function<String, Integer>() {
                            /*toMap的第二个形参表示值的生成规则，此时值是年龄，年龄是整型（整型是基本数据类型，但此时要泛型，就要用包装类），所以第二个形参Function接口的第二个泛型是Integer型；*/
                            @Override
                            public Integer apply(String s) {
                                //s此时代表stream流中的每一个数据即集合中的每一个元素，如张无忌-男-15，被-切割后得到的数组中0索引是姓名，1索引是性别，2索引是年龄
                                String[] result = s.split("-");
                                //此时result的2索引表示年龄，但是此时的年龄是字符串型，所以要转为整型
                                int age = Integer.parseInt(result[2]); //有自动拆箱的功能
                                return age;
                            }
                        }));
​
        //4.打印map集合
        System.out.println(map);
​
        //运行结果为{张强=20, 张良=35, 张翠山=40, 王二麻子=37, 张三丰=100, 张无忌=15, 谢广坤=41}
    }
}
​

使用lambda表达式简化后：

package com.itheima.a02test;
​
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;
​
public class Test4 {
    public static void main(String[] args) {
        //1.创建集合
        ArrayList<String> list = new ArrayList<>();
​
        //2.添加元素
        Collections.addAll(list, "张无忌-男-15", "周芷若-女-14", "赵敏-女-13", "张强-男-20",
                "张三丰-男-100", "张翠山-男-40", "张良-男-35", "王二麻子-男-37", "谢广坤-男-41");
​
        //3.过滤元素并收集
        Map<String, Integer> map = list.stream()
                .filter(s -> "男".equals(s.split("-")[1])) //意味着只把性别为男的留下
                .collect(Collectors.toMap(
                        s -> s.split("-")[0],
                        s -> Integer.parseInt(s.split("-")[2])));
                //s此时代表stream流中的每一个数据即集合中的每一个元素，如张无忌-男-15，被-切割后得到的数组中0索引是姓名，1索引是性别，2索引是年龄
​
        //4.打印map集合
        System.out.println(map);
​
        //运行结果为{张强=20, 张良=35, 张翠山=40, 王二麻子=37, 张三丰=100, 张无忌=15, 谢广坤=41}
    }
}

​

四.注意事项：

核心：

双列集合Map的键不能重复，值可以重复，因此使用collect方法将数据收集到Map集合中一定要保证键不重复，如果键重复了打印Map集合等操作会报错，原因和只有两个形参的toMap方法有关

上述图片中第1438行代码的uniqKeysMapAccumulator方法的形参分别是键的规则和值的规则，uniqKeysMapAccumulator方法的方法体如下：

上述图片中第181行代码会调用putIfAbsent方法，putIfAbsent方法的形参依次是键和值，putIfAbsent方法的方法体如下：

上述图片中第837行的putIfAbsent方法的形参中K key是键， V value是值，在putIfAbsent方法的方法体中，（第838行代码）会先通过键找值（v是值），

如果值是null，表示当前的键是第一次出现，就会执行if语句把数据添加到Map集合中，再返回值；

如果值不是null，表示此时的键不是第一次出现，就不会执行if语句即不会添加数据到Map集合中，会直接返回值。

上述图片中第182行代码会对值即u进行判断，如果u即值不是null，就会抛出一个异常duplicateKeyException(k, u, v)。

五.总结：

Java 8 Stream API深度解读：全方位探索collect()方法及其应用实践
java专栏
04-19 1124
对于更复杂的收集逻辑，可以自定义Collector接口的实现。supplier()：提供一个用于存放结果的容器（如空列表或空映射）。：定义如何将流元素添加到容器中。combiner()：当流并行处理时，定义如何合并两个部分结果容器。finisher()（可选）：对容器进行最终处理，得到最终结果。Java378 // 自定义收集器，收集首字母并保持顺序15 )16 );1720 }21}用于创建自定义收集器，传入SupplierCombiner以及可选的Finisher。
Java Stream流的详解
流楚丶格念的博客
07-18 2980
Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。Java8中的Stream是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作(aggregateoperation)，或者大批量数据操作(bulkdataoperation)。StreamAPI借助于同样新出现的Lambda表达式，而且使用并发模式，极大的提高编程效率和程序可读性。...
Java 8 Stream 的终极技巧——Collectors 功能与操作方法详解
08-19
主要介绍了Java 8 Stream Collectors 功能与操作方法,结合实例形式详细分析了Java 8 Stream Collectors 功能、操作方法及相关注意事项,需要的朋友可以参考下
深入探究 Java Stream 的 collect 与 reduce 操作
最新发布
潜意识Java的博客
06-23 1004
通过合理选择 collect 和 reduce，可以使代码更加简洁、高效，同时充分发挥 Stream API 的优势。
Stream流中collect方法
李长渊的博客
05-07 1万+
Stream流中collect方法
JDK8辅助学习(四)：Stream流 collect() 方法的详细使用介绍
扛麻袋的少年的博客
01-10 5万+
Stream流 collect() 方法的使用介绍 //1. <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner); //2....
Stream流的Collect方法详解
NaZiMeKiY的博客
04-15 764
重新收集出来的数据分别为List的形式与Set的形式，也就是说它们分别包含了List集合和Set集合的特点，它们之间的区别就是List集合和Set集合的区别。1.使用collect(Collectors.toList())的方式将数据收集到List集合当中。3.使用collect(Collectors.toMap())的方式将数据收集到map集合当中。注意点1：如果要把数据收集到Map集合当中，键不能重复，要符合Map集合的特点，否则会报错。那么收集到这两种不同的集合当中的区别是什么呢？
Stream类的collect方法
kanpiaoxue的专栏
02-28 407
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流（详解）
热门推荐
m0_60489526的博客
08-29 8万+
一、Stream流引入 Lambda表达式，基于Lambda所带来的函数式编程，又引入了一个全新的Stream概念，用于解决集合类库既有的鼻端。（Lambda表达式详解在上篇博客内容） 现有一个需求： 将list集合中姓张的元素过滤到一个新的集合中 然后将过滤出来的姓张的元素中，再过滤出来长度为3的元素，存储到一个新的集合中 1.用常规方法解决需求 /...
Stream流
m0_46702681的博客
06-03 2622
filter过滤，limit获取前几个元素，skip跳过前几个元素，distinct 元素去重，依赖(hashcode和equal法)，concat(Stream a, Stream b) 合并a和b两个流为一个流，map转换流中的数据类型，forEach遍历，count()统计，toArray() 收集流中的数据放到数组中，collect(Collector collector)收集流中的数据，放到集合中（list,set,map），过滤奇数，只留下偶数。并将结果保存起来，将结果收集到Map集合中
Java Stream流详解：从入门到精通
qq_38955667的博客
05-11 1995
Stream流是Java 8引入的处理集合数据的API，它让我们以声明式（描述要做什么，而不是怎么做）的方式处理数据。核心特点声明式编程：更关注做什么，而不是怎么做支持链式操作：可以像搭积木一样组合多个操作支持并行处理：轻松切换到并行模式，提高性能延迟执行：在最后一步（终端操作）才会真正执行创建流：从数据源获取流中间操作：对流进行一系列转换和处理（延迟执行）终端操作：触发流的计算，返回结果中间操作：返回新Stream的操作，可以链式调用，不会立即执行。
详解Java8 Collect收集Stream的方法
08-27
主要介绍了Java8-Collect收集Stream的方法，提到了收集器的作用，连接收集器的方法,需要的朋友可以参考下
JAVA Stream的collect用法与原理
秃头的博客
11-12 2607
toList toSet toCollection toMap counting summingInt averagingInt joining maxBy minBy groupingBy partitioningBy collectingAndThen mapping
Java8 Stream收集器collect操作
老猫喜欢今日爬山的博客
06-29 1261
最终返回Map。： 将Stream中的元素，分为两组: predicate通过的分到key为true的组，否者分到key为false的组，然后通过downstream再对每组进行统计(得到统计结果D)，最后得到并返回Map。提示： 串行流下的reduce与并行流下的reduce可能结果不一样，如果不太熟悉的话，建议使用stream的reduce()，而不使用.stream().collect(Collectors.reducing())。
Stream中关于collect方法的介绍
第二庄
06-15 4万+
在Stream 的API中可以查到有两种collect方法，分别是： 第一种： &lt;R, A&gt; R collect(Collector&lt;? super T, A, R&gt; collector); 第二种： &lt;R&gt; R collect(Supplier&lt;R&gt; supplier, BiConsumer&lt;R, ? super T&gt; ...
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
Stream流学习（五）collect操作
weixin_44141172的博客
08-12 256
Stream流 collect操作
Java8 Stream流中的 collect() 方法，远比你想象中的强大
Java笔记虾
07-22 2757
点击关注公众号，利用碎片时间学习Stream流 collect() 方法的使用介绍//1. <R>Rcollect(Supplier<R>supplier, BiConsumer<R,?superT>accumulator, BiConsumer&lt...
stream流终结方法
09-23
stream流的终结方法有很多种，常见的包括： 1. forEach()：对流中的每个元素执行指定操作。 2. toArray()：将流中的元素转换为数组。 3. reduce()：对流中的元素进行归约操作，返回一个值。 4. collect()：将流中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值