跳到主要内容
约 12 分钟3 张卡

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));

顺序流执行时,收集过程分三步:

  1. 创建一个空 ArrayList。
  2. 遍历元素,逐个调用 add。
  3. 返回累积完成的列表。

结果是一个只包含活跃用户、可以修改的 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 一定更快吗?​

9.3 怎样同时计算多个统计值?​

9.4 收集结果可以包含 null 吗?​

10. 面试题卡片​

11. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明