list并行流parallel的使用，Collectors进行分组分区，自定义Collector的使用方式

最新推荐文章于 2026-05-02 05:18:24 发布
原创 最新推荐文章于 2026-05-02 05:18:24 发布 · 2k 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java
本文介绍了如何使用Java Stream API的并行流（parallelStream）进行数据处理，包括过滤、映射、分组和分区，并展示了如何自定义Collector实现定制化的数据收集。同时，详细讲解了如何使用`maxBy`和`minBy`计算最高分和最低分，以及统计基本统计信息。

list并行流parallel的使用，Collectors进行分组分区

	public static void main(String[] args) {
		Student s1 = new Student("zhangsna",90);
		Student s2 = new Student("wang",45);
		Student s3 = new Student("zhaosl",50);
		Student s4 = new Student("zhaosl",50);
		Student s5 = new Student("xx",50);
		
		List<Student> list = Arrays.asList(s1,s2,s3,s4,s5);
		//通过filter以对象中的一个属性作为条件过滤
		//找出分数大于60的学生对象
		list.stream().filter(s -> s.getScore() > 60).collect(Collectors.toList()).forEach(System.out::println);  //zhangsna 90
		//找出分数大于60的分数
		list.stream().map(s -> s.getScore()).filter(s -> s > 60).collect(Collectors.toList()).forEach(System.out::println);  //90
		
		//parallelStream并行流 与串行流向对sequential相对 当使用并行流parallel时程序会根据cpu核数算出一个默认启用的线程数，开启多个线程并行处理数据
		//mapToInt mapToLong mapToDouble为处理对应类型的特定方法，使得处理对应数据时减少拆装箱的损耗
		//使用并行流计算最后得到数组
		int[] arr2 = list.parallelStream().mapToInt(s -> s.getScore()).filter(s -> s < 60).toArray();
		//使用并行流计算最后得到集合
		List<Integer> scoreList = list.parallelStream().mapToInt(s -> s.getScore()).filter(s -> s < 60).boxed().collect(Collectors.toList());
		
		//使用Collectors获取最高分数和最低分数的学生对象
		list.stream().collect(Collectors.maxBy(Comparator.comparingInt(Student::getScore))).ifPresent(System.out::println); //zhangsna 90
		list.stream().collect(Collectors.minBy(Comparator.comparingInt(Student::getScore))).ifPresent(System.out::println); //wang 45
		
		//计算该集合中的score常规统计的基本信息
		IntSummaryStatistics iss = list.stream().collect(Collectors.summarizingInt(s -> s.getScore()));
		System.out.println(iss); //IntSummaryStatistics{count=5, sum=285, min=45, average=57.000000, max=90}
		
		System.out.println("-------------------分组groupingBy与分区partitioningBy-----------------");
		//分组与多级分组
		//groupingBy 类似与 sql中的group by
		//以姓名为分组条件将集合分组
		Map<String, List<Student>> group = list.stream().collect(Collectors.groupingBy(Student::getName));
		System.out.println(group); //{xx=[xx 50], zhaosl=[zhaosl 50, zhaosl 50], wang=[wang 45], zhangsna=[zhangsna 90]}
		
		//以分数大于等于60为分区条件进行分区
		Map<Boolean, List<Student>> partition = list.stream().collect(Collectors.partitioningBy(s -> s.getScore() >= 60));
		System.out.println(partition);  //{false=[wang 45, zhaosl 50, zhaosl 50, xx 50], true=[zhangsna 90]}
		
		//接口支持多级分区分组
		//先以分数大于等于60进行分区，再按姓名进行分组
		Map<Boolean, Map<String, List<Student>>> partitionThenGroup =list.stream().collect(Collectors.partitioningBy(s ->s.getScore() >60,Collectors.groupingBy(Student::getName)));
		System.out.println(partitionThenGroup); //{false={xx=[xx 50], zhaosl=[zhaosl 50, zhaosl 50], wang=[wang 45]}, true={zhangsna=[zhangsna 90]}}
		
		//分区后统计各区数据
		Map<Boolean, IntSummaryStatistics> partitionThenPartition = list.stream().collect(Collectors.partitioningBy(s -> s.getScore() > 80,Collectors.summarizingInt(Student::getScore)));
		System.out.println(partitionThenPartition); //{false=IntSummaryStatistics{count=4, sum=195, min=45, average=48.750000, max=50}, true=IntSummaryStatistics{count=1, sum=90, min=90, average=90.000000, max=90}}
}

自定义收集器Collector

import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

//自定义一个收集器需要实现Collector接口
public class MyCollector<T> implements Collector<T, Set<T>, Set<T>> {

	//实现supplier接口，该接口为收集器提供一个容器
	@Override
	public Supplier<Set<T>> supplier() {
//		return () -> new HashSet<T>();
		return HashSet<T>::new;
	}

	//实现accumulator接口，该接口提供一个向容器添加元素的方法
	@Override
	public BiConsumer<Set<T>, T> accumulator() {
		return (set,item) -> set.add(item);
	}

	//实现combiner接口，该接口在并行流时提供一个向容器添加另一个容器的方法
	@Override
	public BinaryOperator<Set<T>> combiner() {
		return (set1, set2) -> {
			set1.addAll(set2);
			return set1;
		};
	}

	//实现finisher接口，该接口提供一个方法在结束时可以对容器进行处理
	@Override
	public Function<Set<T>, Set<T>> finisher() {
		return set -> set;
	}

	//characteristics接口中声明收集器的特性
	//Characteristics.IDENTITY_FINISH 忽略finisher接口 当选用此参数时将不会执行finisher()
	//Characteristics.UNORDERED 无序的表示该收集器可以收集一个无序的集合
	//Characteristics.CONCURRENT 表示该收集器容器是一个线程安全的容器，在使用CONCURRENT后选用并行流时，将不会生成多个容器再整合的模式而是多个线程操作一个容器
	@Override
	public Set<Characteristics> characteristics() {
		return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH,Characteristics.UNORDERED));
	}

}
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;

public class MyCollector2<T> implements Collector<T, Set<T>, Map<T,T>> {

	@Override
	public Supplier<Set<T>> supplier() {
//		return () -> new HashSet<T>();
		return HashSet<T>::new;
	}

	@Override
	public BiConsumer<Set<T>, T> accumulator() {
		return (set,item) -> set.add(item);
	}

	@Override
	public BinaryOperator<Set<T>> combiner() {
		return (set1, set2) -> {
			set1.addAll(set2);
			return set1;
		};
	}

	//使用自定义收集器的finisher方法重写，将结束后的结果整合成一个map类
	@Override
	public Function<Set<T>, Map<T,T>> finisher() {
		Map<T,T> map = new HashMap<>();
		return set -> {
			set.forEach(t -> {
				map.put(t, t);
			});
			return map;
		};
	}

	@Override
	public Set<Characteristics> characteristics() {
		return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED));
	}

}
	public static void main(String[] args) {
		Student s1 = new Student("zhangsna",90);
		Student s2 = new Student("wang",45);
		Student s3 = new Student("zhaosl",50);
		Student s4 = new Student("zhaosl",50);
		Student s5 = new Student("xx",50);
		
		List<Student> list = Arrays.asList(s1,s2,s3,s4,s5);

		//自定义收集器
		MyCollector<Student> myCollector = new MyCollector<>();
		
		Set<Student> set = list.stream().filter(s -> s.getScore() < 60).collect(myCollector);
		set.forEach(System.out::println); //zhaosl 50  zhaosl 50  wang 45  xx 50
		
		//自定义一个收集器将结果转换为map类型
		MyCollector2<String> myCollector2 = new MyCollector2<>();
		List<String> list1 = Arrays.asList("a","b","c");
		Map<String,String> map = list1.stream().collect(myCollector2);
		System.out.println(map); //{a=a, b=b, c=c}
	}

等风来_aa
关注
【人工智能智算中心】计费系统篇03-智算业务计费
weixin_49199313的博客
08-08 1100
动态批价与规则引擎的协同本质是 ​​“策略与执行解耦”+“实时上下文驱动”​​技术协同​：规则引擎定义业务逻辑（What），批价引擎执行计算（How），通过缓存、事件总线和动态注入实现高效联动；​架构演进​：从单体规则中心 → 微服务化 → 事件驱动分层，核心目标是提升扩展性、降低时延；​关键突破​：​实时性​：电信OCS通过规则引擎实现秒级信用控制；​灵活性​：电商将促销规则拆分为独立AO服务，避免单点故障；​精准性​：物流动态权重模型量化距离、燃油等因子，误差率<5%。
Java8 遍历List 使用stream().parallel()并发安全
qiaobing1226的博客
12-07 8179
引入了并行流的概念来进行并行处理，而并行流(Parallel Stream)利用所有可用CPU内核的优势，并并行处理任务。其原理(Parallel Stream)是可以把大任务分成多个小任务执行, 最后再把执行结果进行合并, ForkJoinPool用工作窃取算法实现。
Java List parallelStream并行流
鸟人的博客
07-11 3236
Java中List的parallelStream线程流技术，可以很方便的帮我实现多线程，下面结合一个案例来看看效率的优化使用MyBatis框架向MySQL写入100000条数据，对比使用parallelStream和没有使用parallelStream小路的区别 耗时157s 耗时100s 总结 使用parallelStream会比没有使用parallelStream的速度更快...........................
告别编译噩梦：用Vcpkg+VS2019在Windows上丝滑配置OpenMVS（附常见错误排查清单）
最新发布
weixin_30700977的博客
05-02 608
本文详细介绍了在Windows平台上使用Vcpkg和VS2019丝滑配置OpenMVS的完整指南，包括环境准备、依赖管理、项目编译及常见错误排查。通过Vcpkg简化依赖库管理，结合VS2019开发环境，帮助开发者高效完成OpenMVS的环境配置，避免编译噩梦。
list中parallelStream流慎用
qq_37342720的博客
07-23 3625
list流常用
Java8新特性 - 并行流
Javaer`s blog
11-20 437
在Java 7之前，并行处理数据集合非常麻烦 第一，你得明确地把包含数据的数据结构分成若干子部分 第二，你要给每个子部分分配一个独立的线程 第三，你需要在恰当的时候 对它们进行同步来避免不希望出现的竞争条件 等待所有线程完成，最后把这些部分结果合并起 来 Java 7引入了一个叫作分支/合并的框架，让这些操作更稳定、更不易出错 Strean流将外部迭代转换为内部迭代，它允许声明性地将顺序流转换为并行流，在幕后使用分支合并框架能透明地进行并行处理 1. 使用并行流 获取一个并行流是非常简单的，有如下两种方
java8 Stream 常用方法讲解
qq_42087460的博客
09-29 928
Java 8 Stream java8 中新增了一种Stream流的特性，这种方式跟写SQL似的，一个集合看成一个数据表，Stream看成条件，然后返回一个新的数据。 Steam API 可以极大提高程序员的效率，可以让程序员写出高效，干净，简洁的代码，唯一一点不好的地方就是如果程序员不会这个你会看不懂。 java8中有两种方法来生成流 1. stream() -为集合创建串行流 2. parallelStream() -为集合创建并行流 就是一个单线程，一个多线程的意思。 Stream
Collectors - The Collector interface
Faith, Simpleness, Transparency, Innovation
07-01 249
lt;A, T&gt; accumulator(); BinaryOperator&lt;A&gt; combiner(); Function&lt;A, R&gt; finisher(); Set&lt;Collector.Characteristics&gt; characteristics(); } Note: T is the generic type of the items in the st
java8 stream使用笔记、静态方法引用等
enthan809882的博客
01-17 1万+
java8 stream使用笔记
Java 8新特性：list.stream()的相关操作
跨越时空的记忆
07-01 4926
Java 8新特性：list.stream()的相关操作 获取对象list集合中的某个属性使其成为一个新的集合 清空对象list集合中的某个属性的值并返回结果 过滤出符合条件的元素 组成新的集合 去除list集合中重复元素 剩余的元素组成新的集合 跳过list集合中前三个元素 剩余的元素组成新的集合 获取list集合中前三个元素 组成新的集合 list集合转为map集合，从学生对象中取出一个字段的值作为map的key，学生对象则为value......
并行处理集合List Demo
duke天地
12-06 982
并行处理集合List Demo 在实际的业务场景中经常出现一个集合需要轮询处理,可以使用Java提供的ExecutorService来处理 import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.concurrent.*; /** * 多线程并发处理一个List集...
Java 8中的parallelStream()方法：并行处理数据集合-＞加快List循环速度
weixin_46432232的博客
08-01 3020
但需要注意的是，并非所有情况下都适合使用并行处理，因为并行处理会带来一些额外的开销，例如线程调度和数据拆分。引言： 在Java 8中，引入了许多新的特性和API，其中一个重要的特性是Stream API。接口提供的一个方法，它返回一个并行流。是Stream API中的一个强大的功能，它使得我们可以轻松地将数据集合并行处理，从而充分利用多核处理器的优势，提高处理性能。由于并行处理，输出的结果可能会是乱序的，这是因为不同线程的执行顺序是不确定的。在上面的示例中，我们创建了一个包含100万个整数的列表，并使用。
springboot连接数据源的坑
qq_41501190的博客
12-13 528
配置数据源 spring: datasource: data-username: root data-password: 1511 driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/springboot?characterEncoding=utf8 显示的错误 java.sql.SQLSyntaxErrorException: Access denied for
List分段
梁诗傑的博客
01-26 707
private static <T> List<List<Wuzicaigoujihuamingxi>> splitList(List<Wuzicaigoujihuamingxi> collection, int splitSize) { if(CollectionUtils.isEmpty(collection)) { return Collections.emptyList(); } int maxSize = collection.s.
java List的stream()方法解析
热门推荐
dd2016124的博客
01-18 2万+
java List的stream()方法解析
Parallel.ForEach处理List导致数据丢失
yeyueliulang的专栏
04-03 715
是在一个普通的foreach循环中被填充，而是在一个并行循环中被填充。问题出现在对的操作上，因为List<T>类型不是线程安全的。当你在中使用时，可能会有多个线程同时尝试向添加元素。由于List<T>没有同步机制来保护其内部数据结构，在并发环境下这可能导致数据丢失或异常，从而使得的最终元素数量与dt.Rows的行数不一致。
Java的并行流parallelStream之结果被收集后排序分析
weixin_44185736的博客
11-13 3798
一、先说结论 parallelStream在中间处理时都是并行的（这里不展开说明并行的实现），所以parallelStream中间处理的结果都是乱序的，但是在使用了Collect收集器后，parallelStream被收集的结果默认都是按照集合的原序列进行排序的。 二、实例测试 2.1、先上代码 /** * collect 收集时可以排序成原数组数据 */ @Test public void myParallelTest() { List<Inte
java 集合分割和并行处理
Crystalqy的博客
02-09 6849
在项目中经常会遇到一个很大的List集合需要处理，如果直接循环遍历的话性能会很差，需要考虑对list进行处理，本次提供一种思路，将大集合拆分为多个小的集合，同时对这些小集合进行并行处理； 下面提供两种集合分割的方法： 一、将一个list均分成n个list /** * 将一个list均分成n个list * * @param source * @param n : ...
并发编程：并行反应式流：收集流（collect）
博风_刺耳的博客（网络记事本）
09-03 888
收集流中的元素，collect方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值