Java Stream Collector 高级用法：定制化累加器与收集器实现
本文深入探讨了JavaStreamAPI中Collector的高级定制化实现，重点讲解了如何灵活选择和设计累加器类型(A)，以及如何使用Collector.of()方法构建自定义收集器。通过具体示例，展示了利用基本类型数组、现有可变类型、匿名内部类等作为累加器，有效避免了不必要的类创建，提升了代码的简洁性和灵活性。
理解 Collector 接口及其泛型
java.util.stream.Collector 接口是 Java Stream API 中一个核心组件，用于将流中的元素聚合成一个结果。它定义了三种泛型类型：
- T：流中元素的类型。
- A：累加器（accumulator）的类型，这是一个可变的中间结果类型，用于在收集过程中存储状态。它通常是实现细节，不对外暴露。
- R：最终结果的类型，即收集操作完成后返回的类型。
要创建一个自定义的 Collector，最常用的方法是使用 Collector.of() 工厂方法，它需要四个核心函数式接口作为参数：
- supplier: 一个 Supplier，用于创建新的累加器实例。
- accumulator: 一个 BiConsumer
- combiner: 一个 BinaryOperator，用于将两个累加器 A 合并成一个（在并行流中特别有用）。
- finisher: 一个 Function
一个常见的误解是，累加器类型 A 必须是一个独立的、专门为此目的创建的具名类，并且其方法（如 supply、accumulate、combine、finish）需要直接在 Collector 的实现中引用该类的静态方法或实例方法。实际上，Collector.of() 的函数参数提供了极大的灵活性，允许我们使用各种方式来定义这些行为，而无需强制创建额外的具名类。
灵活选择累加器类型
累加器类型 A 的选择是实现自定义 Collector 的关键。它不一定非得是一个复杂的自定义类，可以是以下几种类型：
1. 使用基本类型数组作为累加器
对于简单的数值累加，一个单元素的基本类型数组（如 int[]）是一个非常高效且简洁的累加器。它提供了可变性，并且避免了装箱拆箱的开销。
示例：计算流中整数的和
import java.util.stream.Collector;
import java.util.stream.Stream;
public class CustomSumCollector {
/**
* 创建一个收集器，用于计算整数流的总和。
* 累加器类型为 int[1]，其中数组的第一个元素存储当前和。
*
* @return 收集整数到其总和的收集器。
*/
public static Collector sum() {
return Collector.of(
() -> new int[1], // supplier: 创建一个长度为1的int数组作为累加器
(a, i) -> a[0] += i, // accumulator: 将元素i加到数组的第一个元素
(a, b) -> { a[0] += b[0]; return a; }, // combiner: 合并两个累加器
a -> a[0], // finisher: 返回数组的第一个元素作为最终结果
Collector.Characteristics.UNORDERED // 标识收集器不关心元素顺序
);
}
public static void main(String[] args) {
Stream numbers = Stream.of(1, 2, 3, 4, 5);
Integer totalSum = numbers.collect(sum());
System.out.println("Sum using custom collector: " + totalSum); // Output: Sum using custom collector: 15
}
} 在这个例子中，int[1] 作为累加器 A，简洁地完成了累加任务。
2. 使用现有可变类型作为累加器
Java 标准库中提供了许多可变的类，它们可以直接用作累加器，特别是当需要考虑线程安全时。
示例：使用 AtomicInteger 计算流中整数的和（并发安全）
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class ConcurrentSumCollector {
/**
* 创建一个并发安全的收集器，用于计算整数流的总和。
* 累加器类型为 AtomicInteger。
*
* @return 并发收集整数到其总和的收集器。
*/
public static Collector concurrentSum() {
return Collector.of(
AtomicInteger::new, // supplier: 创建一个新的 AtomicInteger 实例
AtomicInteger::addAndGet, // accumulator: 将元素i原子地加到 AtomicInteger 中
(a, b) -> { a.addAndGet(b.intValue()); return a; }, // combiner: 合并两个 AtomicInteger
AtomicInteger::intValue, // finisher: 返回 AtomicInteger 的值作为最终结果
Collector.Characteristics.UNORDERED,
Collector.Characteristics.CONCURRENT // 标识收集器支持并发
);
}
public static void main(String[] args) {
Stream numbers = Stream.of(1, 2, 3, 4, 5);
Integer totalSum = numbers.collect(concurrentSum());
System.out.println("Concurrent sum using custom collector: " + totalSum); // Output: Concurrent sum using custom collector: 15
}
} AtomicInteger 天然提供了线程安全的原子操作，非常适合在并行流中使用。
3. 使用匿名内部类或 Ad-hoc 类型作为累加器
当没有合适的现有类型，并且不想创建新的具名类时，可以使用匿名内部类或 Object 的子类（通常通过 new Object() {} 语法）作为累加器。这种方式将累加器的定义局部化在 Collector 的实现内部，增加了封装性。
示例：收集 Map.Entry 流中具有最大值的键列表
假设我们有一个 Map.Entry
方法一：使用 AbstractMap.SimpleEntry 作为累加器
AbstractMap.SimpleEntry 可以作为一个简单的键值对容器，这里我们用它来存储当前找到的最大值 (Integer) 和对应的键列表 (List
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class KeysToMaximumCollector {
/**
* 收集 Map.Entry 流中具有最大值的键列表。
* 累加器类型为 AbstractMap.SimpleEntry, Integer>。
*
* @param 键的类型
* @return 收集器，返回具有最大值的键列表。
*/
public static Collector, ?, List> keysToMaximum() {
return Collector.of(
() -> new AbstractMap.SimpleEntry<>(new ArrayList<>(), Integer.MIN_VALUE), // supplier: 初始累加器
(current, next) -> { // accumulator: 处理每个 Map.Entry
int max = current.getValue();
int value = next.getValue();
if (value >= max) {
if (value > max) { // 找到更大的值，清空旧列表，更新最大值
current.setValue(value);
current.getKey().clear();
}
current.getKey().add(next.getKey()); // 添加当前键
}
},
(a, b) -> { // combiner: 合并两个累加器
int maxA = a.getValue();
int maxB = b.getValue();
if (maxA < maxB) return b; // B 的最大值更大，返回 B
if (maxA == maxB) a.getKey().addAll(b.getKey()); // 最大值相同，合并键列表
return a; // 否则返回 A
},
Map.Entry::getKey // finisher: 返回累加器中的键列表
);
}
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("A", 10);
map.put("B", 20);
map.put("C", 15);
map.put("D", 20);
map.put("E", 5);
List keys = map.entrySet().stream().collect(keysToMaximum());
System.out.println("Keys with maximum value: " + keys); // Output: Keys with maximum value: [B, D] (顺序可能不同)
}
} 方法二：使用匿名内部类作为累加器
这种方式创建了一个只在 Collector 内部可见的、具有特定字段的匿名对象作为累加器。
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class KeysToMaximumAdHocCollector {
/**
* 收集 Map.Entry 流中具有最大值的键列表。
* 累加器类型为匿名内部类。
*
* @param 键的类型
* @return 收集器，返回具有最大值的键列表。
*/
public static Collector, ?, List> keysToMaximum() {
return Collector.of(
() -> new Object() { // supplier: 创建一个匿名内部类实例作为累加器
int max = Integer.MIN_VALUE;
final List keys = new ArrayList<>();
},
(current, next) -> { // accumulator: 处理每个 Map.Entry
int value = next.getValue();
if (value >= current.max) {
if (value > current.max) {
current.max = value;
current.keys.clear();
}
current.keys.add(next.getKey());
}
},
(a, b) -> { // combiner: 合并两个匿名内部类累加器
if (a.max < b.max) return b;
if (a.max == b.max) a.keys.addAll(b.keys);
return a;
},
a -> a.keys // finisher: 返回累加器中的键列表
);
}
public static void main(String[] args) {
Map map = new HashMap<>();
map.put("A", 10);
map.put("B", 20);
map.put("C", 15);
map.put("D", 20);
map.put("E", 5);
List keys = map.entrySet().stream().collect(keysToMaximum());
System.out.println("Keys with maximum value (ad-hoc): " + keys); // Output: Keys with maximum value (ad-hoc): [B, D] (顺序可能不同)
}
} 这两种方法都避免了为累加器单独创建一个具名类，使代码更加紧凑和局部化。
注意事项与总结
累加器类型的选择：
- 简单场景：考虑使用基本类型数组（如 int[]）或现有可变容器（如 ArrayList、StringBuilder）作为累加器，它们通常更高效且简洁。
- 并发场景：使用 AtomicInteger、ConcurrentHashMap 等并发工具类作为累加器，并添加 Collector.Characteristics.CONCURRENT 特性。
- 复杂场景或封装需求：当需要封装多个状态时，可以考虑 AbstractMap.SimpleEntry 或匿名内部类。如果逻辑非常复杂，或者该累加器类型需要在多个 Collector 中复用，那么创建一个具名类仍然是更好的选择。
函数式接口的实现：
- supplier、accumulator、combiner、finisher 可以是方法引用 (ClassName::methodName) 或 Lambda 表达式。它们不要求是累加器类型 A 自身的成员方法，这提供了极大的灵活性。
- combiner 函数的正确实现对于并行流至关重要。它必须能够正确地将两个部分累加器合并为一个。
- finisher 函数负责将中间的累加器状态转换为最终结果。如果累加器本身就是最终结果，finisher 可以简单地返回累加器本身（即 Function.identity()）。
Collector.Characteristics：
- UNORDERED：表示收集器不关心流的顺序。
- CONCURRENT：表示收集器可以支持并行执行，即 accumulator 可以被多个线程调用，并且 combiner 可以被跳过（如果 supplier 返回一个线程安全的可变结果容器）。
- IDENTITY_FINISH：表示 finisher 函数是一个恒等函数（Function.identity()），即累加器类型 A 和结果类型 R 相同。
通过灵活运用 Collector.of() 方法，并根据实际需求选择合适的累加器类型，开发者可以创建出高效、简洁且功能强大的自定义收集器，从而更好地利用 Java Stream API 的能力。无需为每个自定义收集器都创建独立的累加器类，这大大简化了代码结构和维护成本。
正软商城本月促销专区，汇集办公、设计、安全、影音、系统工具及AI软件等正版软件优惠活动，提供限时折扣、特价授权和优惠购买信息，活动库存及价格以页面实时展示为准。
正软商城装机必备专区，精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件，帮助用户快速完成新电脑软件配置。
正软商城Windows软件专区，汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件，提供软件介绍、系统要求、正版授权及购买下载服务。
正软商城macOS软件专区，精选适用于Mac电脑的办公、设计、影音、效率、开发和系统工具，提供软件功能介绍、macOS兼容版本、正版授权及购买下载服务。
正软商城iOS软件专区，精选适用于iPhone和iPad的办公、学习、影音、设计、效率及AI应用，提供功能介绍、适用设备、系统要求和正版获取方式等信息。
正软商城AI软件专区，汇集AI写作、AI绘画、AI视频、AI办公、AI编程、AI翻译、智能客服和数据分析等人工智能工具，提供功能介绍、适用平台、收费方式及正版购买信息。
正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法，同时介绍常用PDF软件和工具的使用技巧。
赤友清理大师是一款为 Mac 设计的智能清理优化工具，可精准扫描垃圾、大文件、重复文件等，释放磁盘空间。做扫描整理、文字提取和表格转换时，它能把识别后的处理步骤接得更顺，资料录入这类场景会省下不少时间。
极度公式是一款跨平台专业LaTeX公式识别编辑软件，支持OCR公式识别和多平台编辑。和使用说明，避免使用，享受完整功能与稳定支持。做扫描整理、文字提取和表格转换时，它能把识别后的处理步骤接得更顺，资料录入这类场景会省下不少时间。
一款文字处理软件，一种订阅式的跨平台办公软件，基于云平台提供多种服务，通过将 Excel 和 Outlook 等应用与 OneDrive 和 Microsoft Teams 等强大的云服务相结合，Office 365 可让任何人使用任何设备随时随地创建和共享内容。
CodeExpander 是一款快捷短语输入增强工具，通过键入缩写自动展开为自定义文段，提升工作效率。任务管理和过程控制会更完整，持续下载、批量同步或需要稳定传输流程的场景会更适合它。
Mountain Duck 是一款能将多个网盘挂载到本地的工具，像本地磁盘一样使用网盘。清理链路的完整性会更好一些，做应用卸载、残留处理和空间整理时，通常能少走很多手动排查步骤。
极度公式是一款跨平台专业LaTeX公式识别编辑软件，支持OCR公式识别和多平台编辑。和使用说明，避免使用，享受完整功能与稳定支持。做扫描整理、文字提取和表格转换时，它能把识别后的处理步骤接得更顺，资料录入这类场景会省下不少时间。
一款文字处理软件，一种订阅式的跨平台办公软件，基于云平台提供多种服务，通过将 Excel 和 Outlook 等应用与 OneDrive 和 Microsoft Teams 等强大的云服务相结合，Office 365 可让任何人使用任何设备随时随地创建和共享内容。
Wise Folder Hider Pro 是一款专业级文件和文件夹隐藏加密软件，为私密数据添加多重保护。高频操作更强调就近处理，浏览、整理和跨目录移动文件时，来回切换和重复点击都会少很多。
CodeExpander 是一款快捷短语输入增强工具，通过键入缩写自动展开为自定义文段，提升工作效率。任务管理和过程控制会更完整，持续下载、批量同步或需要稳定传输流程的场景会更适合它。
Mountain Duck 是一款能将多个网盘挂载到本地的工具，像本地磁盘一样使用网盘。清理链路的完整性会更好一些，做应用卸载、残留处理和空间整理时，通常能少走很多手动排查步骤。
