Collector
Collector 是 Stream 的收集规则:它规定容器怎样创建、元素怎样加入、最后返回什么结果。collect 按这套规则,把流里的元素累积成列表、Map 或自定义对象。
平时写 Collectors.toList()、groupingBy 时,很少需要想这些规则;但遇到 toMap 抛出重复键异常、结果顺序不对、或者串行正确而并行出错时,就得回到规则本身。常用收集器在去重、顺序、键冲突和空值上各有什么约定?一套收集或归约规则要满足什么条件,才能在并行执行时得到同样的结果?
1. 面试核心
先记住这几条,再读正文collect适合把元素累积到可变容器,reduce适合把元素合并成一个不可变值;用reduce修改共享的可变容器,并行时会出错。卡 · 可变归约- 两参数
toMap遇到重复键会抛出IllegalStateException,第三个参数(合并函数)决定冲突时保留哪个值。卡 · toMap 与键冲突 groupingBy按分类键分组,下游收集器决定每组保存的是列表、计数还是其他统计结果。- 归约的初始值必须是单位元,合并规则必须满足结合律,不同的分区方式才能得到等价结果。卡 · 归约单位元与并发收集
- 普通并行
collect为每个分区创建独立容器,再由combiner合并,所以可以用ArrayList这类非线程安全容器。
2. 可变归约
可变归约是把元素逐个加入一个可修改的容器,最后返回这个容器(或由它转换出的结果)。比如要把活跃用户收集到列表:
List<User> activeUsers = users.stream()
.filter(User::active)
.collect(Collectors.toCollection(ArrayList::new));
顺序流执行时,收集过程分三步:
- 创建一个空
ArrayList。 - 遍历元素,逐个调用
add。 - 返回累积完成的列表。
结果是一个只包含活跃用户、可以修改的 ArrayList。容器由收集过程自己创建和修改,调用方不用在外面维护一个共享列表。并行执行时,输入会被拆成多个分区,每个分区先用自己的容器累积,最后再按 Collector 的规则合并。
2.1 collect 与 reduce
用 collect 还是 reduce,看累积时要不要修改容器。reduce 更适合把元素合成一个不可变的值,比如计算订单金额总和:
int total = orders.stream()
.map(Order::amount)
.reduce(0, Integer::sum);
这里从 0 开始累加每笔金额,空流直接返回 0。初始值 0 叫作 identity(单位元),也就是参与运算后不改变结果的值:0 + x 还是 x。
如果套用同样的写法去修改一个共享的 ArrayList,并行时就会出错:
// 错误示例:并行时多个任务可能共享并修改 identity
List<User> result = users.parallelStream().reduce(
new ArrayList<>(),
(list, user) -> {
list.add(user);
return list;
},
(left, right) -> {
left.addAll(right);
return left;
}
);
问题出在初始列表只有一个。reduce 会把同一个 identity 交给每个并行任务,于是所有任务都在往同一个 ArrayList 里 add。这个列表一旦被改动,就不再是「空列表」,失去了单位元的意义;多个线程同时修改 ArrayList 还可能丢数据,合并时 addAll 又会把同一批元素重复加入。收集可变容器应该用 collect,由它的供应函数为每个分区各自创建容器。
3. Collector 的组成
自定义收集器之前,先要分清三样东西:输入元素、中间容器和最终结果。Collector<T, A, R> 用三个类型参数分别表示它们:
T:Stream 中的元素类型。A:内部累积容器的类型。R:最终结果的类型。
然后用五个组成部分描述收集过程:
| 组成部分 | 作用 |
|---|---|
supplier | 创建新的累积容器 |
accumulator | 把一个元素加入容器 |
combiner | 合并两个分区的容器 |
finisher | 把累积容器转换成最终结果 |
characteristics | 声明并发、顺序和是否无需转换等特征 |
下面是一个简化的字符串拼接 Collector:
Collector<String, StringJoiner, String> commaSeparated = Collector.of(
() -> new StringJoiner(", "),
StringJoiner::add,
StringJoiner::merge,
StringJoiner::toString
);
String names = users.stream()
.map(User::displayName)
.collect(commaSeparated);
这里 T 和 R 都是 String,中间容器 A 是 StringJoiner。每个显示名通过 add 加入拼接器,最后 toString 返回用逗号和空格分隔的字符串。并行时,各分区先各自拼接,再用 merge 合并成一个拼接器,最后转换为字符串。
即使你只打算串行使用,combiner 也要写对。串行时它确实不会被调用,但哪天有人把流改成并行,一个敷衍的 combiner 就会丢数据或打乱顺序。
4. List 与 Set 收集
收集到列表或集合时,要先想清楚三件事:要不要去重,要不要保持顺序,结果允不允许修改。下面把几种写法放在一起:
List<String> names = users.stream()
.map(User::displayName)
.collect(Collectors.toList());
Set<String> roles = users.stream()
.flatMap(user -> user.roles().stream())
.collect(Collectors.toSet());
List<String> immutableNames = users.stream()
.map(User::displayName)
.collect(Collectors.toUnmodifiableList());
LinkedHashSet<String> orderedRoles = users.stream()
.flatMap(user -> user.roles().stream())
.collect(Collectors.toCollection(LinkedHashSet::new));
它们的区别:
names收集所有显示名。Collectors.toList()的契约没有规定具体实现、可变性、线程安全性或可序列化性,所以不要依赖它返回的是可修改的ArrayList。roles用 Set 去重。flatMap先把每个用户的角色展开成一个流,再收集到集合里。immutableNames是不可修改列表,toUnmodifiableList()遇到 null 元素会抛出异常。orderedRoles明确指定了LinkedHashSet,去重的同时保留角色第一次出现的顺序。
需要确定的容器能力时,就像最后一例那样用 toCollection 指定工厂。
Java 16 起还有 Stream.toList(),它明确返回不可修改列表,契约和 Collectors.toList() 不同。几种列表结果对比如下:
| 列表结果 | 可修改性 | null 与版本 |
|---|---|---|
Stream.toList() | 不可修改 | 支持 null,Java 16 起 |
Collectors.toList() | 无可修改性承诺 | 不宜依赖具体实现 |
Collectors.toUnmodifiableList() | 不可修改 | 拒绝 null,Java 10 起 |
toCollection(ArrayList::new) | 可修改 | 支持 null |
「不可修改」限制的是列表的添加、删除和替换。如果列表里放的是可变对象,对象自己的字段仍然可以改,所以列表只读和元素不可变要分开判断。
5. toMap 与键冲突
把列表转成 Map,要先决定键是什么,以及同一个键对应多个值时怎么办。toMap 接收键函数和值函数,Function.identity() 表示直接把输入对象本身作为值。
下面对比三种需求:键唯一、键会重复、需要固定的遍历顺序:
Map<Long, User> usersById = users.stream()
.collect(Collectors.toMap(User::id, Function.identity()));
Map<String, User> latestByEmail = users.stream()
.collect(Collectors.toMap(
User::email,
Function.identity(),
(left, right) -> left.updatedAt().isAfter(right.updatedAt())
? left
: right
));
Map<String, User> ordered = users.stream()
.collect(Collectors.toMap(
User::email,
Function.identity(),
(left, right) -> right,
LinkedHashMap::new
));
usersById按用户 ID 建立映射。两参数版本要求键唯一,只要出现重复键就抛出IllegalStateException,它不会替你随便选一个。latestByEmail按邮箱建立映射,第三个参数是合并函数:同一个邮箱出现两次时,保留更新时间较晚的用户;时间相同时,这个示例保留右值,也就是后遇到的那个。ordered用第四个参数指定LinkedHashMap,键按第一次遇到的顺序遍历;重复邮箱的值由后遇到的用户替换。
合并函数决定冲突时留下什么。选左值、右值还是合成一个新值,都要有明确的业务依据。如果一个键本来就对应多个对象,比如同名的多个人,就不该用合并函数丢掉其中一些,而应该用下一节的分组。
6. groupingBy 与下游 Collector
groupingBy 先用分类函数算出每个元素的键,按键分组,再处理每组的元素。默认每组收集成一个 List;传入下游 Collector 后,由它决定每组的结果是什么。
下面三个例子都按部门分组,区别在于每组收集成什么:
Map<Department, List<User>> usersByDepartment = users.stream()
.collect(Collectors.groupingBy(User::department));
Map<Department, Long> counts = users.stream()
.collect(Collectors.groupingBy(
User::department,
Collectors.counting()
));
Map<Department, Set<String>> roleNames = users.stream()
.collect(Collectors.groupingBy(
User::department,
Collectors.flatMapping(
user -> user.roles().stream(),
Collectors.toSet()
)
));
usersByDepartment的每个值是该部门的用户列表,类型是List<User>。counts用counting()统计每组的用户数,每个值是Long。roleNames用flatMapping把组内用户的角色展开,再用toSet()去重,每个值是Set<String>。
其他常用的下游收集器:
mapping:先转换组内每个元素,再交给下游收集。filtering:只收集组内满足条件的元素。注意,已经出现过的分类键即使没有元素通过过滤,也会保留为一个空组。summingInt、averagingLong:计算组内数值的总和与平均值。maxBy、minBy:按比较器找出组内的最大值和最小值。collectingAndThen:下游收集完成后,再把结果转换成需要的类型。
6.1 partitioningBy
只按一个条件把元素分成两类时,用 partitioningBy。比如把用户分成活跃和非活跃两组:
Map<Boolean, List<User>> partition = users.stream()
.collect(Collectors.partitioningBy(User::active));
结果 Map 固定有 true 和 false 两个键,分别对应活跃和非活跃用户的列表;即使某一类一个用户都没有,它的列表也会以空列表保留。这一点和 groupingBy 不同,groupingBy 只为实际出现过的键建组。按部门这类多值业务键分类时,用 groupingBy。
7. 结合律
并行归约会把数据拆到不同分区分别计算,再把部分结果合并起来,这相当于改变了运算的括号分组。要让不同的拆分方式得到相同结果,合并操作必须满足结合律,也就是换一种括号分组,结果不变:
(a op b) op c == a op (b op c)
整数加法满足这个条件,整数减法不满足:
int value = Stream.of(10, 3, 2)
.reduce(0, (left, right) -> left - right);
顺序流算出的是 ((0-10)-3)-2=-15。但 (10-3)-2=5,而 10-(3-2)=9,括号一换结果就变了。所以这种减法归约不能并行执行,并行时得到什么值取决于怎么拆分。
浮点加法也不满足严格的结合律,因为每一步都有舍入误差。合并次序变了,即使输入相同,结果也可能有微小差异。
自定义 Collector 还要满足这些契约:
- 同一个输入,不管怎样分区,都得到等价的结果。
combiner能正确合并两个独立的累积容器。- 声明
CONCURRENT之前,确认累积容器和累积操作确实支持并发。 - 声明
IDENTITY_FINISH时,A能直接作为R返回。
8. 归约单位元与并发收集
结合律决定能不能改变分组,单位元决定初始值会不会改变结果。reduce(identity, op) 要求 op(identity, x) 等于 x。求和的单位元是 0;如果写成 1,每个并行分区都会从 1 开始累加,分成 4 个分区,结果就多出 4。
三参数 reduce 还要求累积函数和合并函数兼容:把一个元素直接累积到当前结果上,和先把它累积到单位元上、再合并到当前结果,两种做法必须得到相同的结果。
普通 collect 不存在共享容器的问题:供应函数为每个分区创建独立的容器,每个容器在累积时只被一个线程使用。所以非并发收集器可以放心用 ArrayList,最后由 combiner 把各分区的结果合起来。
如果想让多个线程往同一个容器里累积,收集器必须声明 CONCURRENT,并且容器真的支持并发写入(例如 ConcurrentHashMap)。此外,流本身要是无序的,或者收集器同时声明 UNORDERED,表示结果不需要保留遇到顺序;否则框架仍会按普通方式为分区创建独立容器。另一个特征 IDENTITY_FINISH 表示累积容器可以直接作为最终结果,框架可以省掉 finisher 这一步。
9. 常见问题
9.1 groupingBy 会保留输入顺序吗?
组内会,外层 Map 不保证。有序流配合 toList 下游时,每组的列表保留遇到顺序;但默认的外层 Map 对键的顺序没有承诺。需要外层键按第一次出现的顺序遍历时,指定 LinkedHashMap;需要按键排序时,用 TreeMap。
Map<Department, List<User>> ordered = users.stream()
.collect(Collectors.groupingBy(
User::department,
LinkedHashMap::new,
Collectors.toList()
));
这个结果里,部门按第一次出现的顺序遍历,每个部门内的用户也保持原来的遇到顺序。
9.2 groupingByConcurrent 一定更快吗?
不一定,要看数据规模、键的分布和下游收集的开销。groupingByConcurrent 返回 ConcurrentMap,采用无序收集语义,多个线程往同一个 Map 里累积,省掉了合并部分结果的工作。但如果大量元素都落在同一个热点键上,线程会在这个键上互相竞争。所以前提是能接受无序结果,然后在实际负载下比较累积和合并的成本。
9.3 怎样同时计算多个统计值?
数值统计可以用 summarizingInt,一次得到数量、总和、最小值、最大值和平均值。两个不相关的统计可以用 teeing(Java 12 起提供,Java 17 与 21 都可用):它让两个收集器处理同一批输入,再用一个函数合并它们的结果。统计口径复杂时,定义一个字段名明确的结果类型,比嵌套 Map 更容易读懂。
9.4 收集结果可以包含 null 吗?
要看收集器和目标容器各自的契约,两者都允许才行。常见的约束:
- OpenJDK 21 的
toMap不接受值映射函数返回 null;键能不能为 null,还取决于具体的 Map 实现。 groupingBy不接受分类函数返回 null,所以分组前要先处理缺少分类键的元素。toUnmodifiableList和toUnmodifiableSet拒绝 null 元素,toUnmodifiableMap拒绝 null 键和值。
也就是说,即使目标容器(比如 HashMap)本身允许 null,上层收集器不允许,结果也一样会抛异常。
10. 面试题卡片
11. 参考资料
- Java API:Collector
- Java API:Collectors
- Java API:Stream.collect
- Java API:Stream.reduce
- OpenJDK 21:Collectors
来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明