理解 java.util.stream.Collector
java.util.stream.Collector 是 Java Stream API 的核心组件之一，用于将流中的元素聚合成一个最终结果。它通过 Collector.of 方法进行构建，该方法接收四个函数作为参数，分别定义了聚合过程的四个阶段：
- supplier: 创建一个新的可变结果容器（accumulator）。
- accumulator: 将流中的单个元素添加到结果容器中。
- combiner: 将两个结果容器合并成一个，用于并行流的合并操作。
- finisher: 对最终结果容器进行转换，得到最终的收集结果。
Collector 接口定义了三个泛型类型：Collector
在实践中，开发者有时会倾向于为累加器 A 创建一个独立的类，然后通过方法引用将其绑定到 Collector.of 的各个函数上。然而，这种做法并非总是必要，Java 提供了更灵活的方式来定义累加器类型，从而简化代码结构。
简化累加器类型：使用原生数组和现有工具类
对于简单的累加操作，我们无需为累加器 A 定义一个全新的类。Java 允许我们使用原生数组或现有的并发工具类作为累加器。
立即学习“Java免费学习笔记（深入）”；
示例一：使用 int[1] 作为累加器实现求和
假设我们需要收集一个整数流的总和。一个简单的 int[1] 数组就可以作为累加器，因为它提供了一个可变的整数存储空间。
import java.util.stream.Collector;
import java.util.stream.Stream;
public class CustomSumCollector {
/**
* 创建一个收集器，用于计算整数流的总和并返回 Integer 类型。
* 累加器类型 A 为 int[1]。
*/
public static Collector sum() {
return Collector.of(
() -> new int[1], // supplier: 创建一个长度为1的int数组作为累加器
(a, i) -> a[0] += i, // accumulator: 将元素i累加到数组的第一个位置
(a, b) -> { // combiner: 合并两个累加器
a[0] += b[0];
return a;
},
a -> a[0], // finisher: 返回数组的第一个位置的值作为最终结果
Collector.Characteristics.UNORDERED // 标记收集器特性
);
}
public static void main(String[] args) {
Integer totalSum = Stream.of(1, 2, 3, 4, 5)
.collect(sum());
System.out.println("Sum using int[1] collector: " + totalSum); // Output: 15
}
} 在这个例子中，int[1] 作为累加器 A，它是一个可变容器，且无需额外的类定义。Collector.of 中的函数通过 Lambda 表达式直接操作这个数组。
示例二：使用 AtomicInteger 作为累加器实现求和（支持并发）
如果需要在并行流中安全地进行累加，可以使用 AtomicInteger。它本身就是线程安全的，非常适合作为并发累加器。
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class CustomAtomicSumCollector {
/**
* 创建一个收集器，用于计算整数流的总和并返回 Integer 类型。
* 累加器类型 A 为 AtomicInteger。
*/
public static Collector sum() {
return Collector.of(
AtomicInteger::new, // supplier: 创建一个新的 AtomicInteger
AtomicInteger::addAndGet, // accumulator: 将元素添加到 AtomicInteger
(a, b) -> { // combiner: 合并两个 AtomicInteger
a.addAndGet(b.intValue());
return a;
},
AtomicInteger::intValue, // finisher: 返回 AtomicInteger 的值
Collector.Characteristics.UNORDERED,
Collector.Characteristics.CONCURRENT // 标记为并发收集器
);
}
public static void main(String[] args) {
Integer totalSum = Stream.of(1, 2, 3, 4, 5)
.parallel() // 使用并行流
.collect(sum());
System.out.println("Sum using AtomicInteger collector (parallel): " + totalSum); // Output: 15
}
} AtomicInteger 作为一个现有的工具类，完美地充当了累加器，并且提供了线程安全的 addAndGet 方法，简化了并发场景下的实现。
处理复杂累加状态：无需专用类
当累加器需要存储不止一个简单值，而是多个相关数据时，我们仍然可以避免创建独立的命名类。可以利用 AbstractMap.SimpleEntry 或匿名内部类作为临时的、局部的累加器类型。
示例三：收集最大值对应的键列表（使用 AbstractMap.SimpleEntry）
假设我们有一个 Map.Entry
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class KeysToMaximumCollector {
/**
* 收集器，用于从 Map.Entry 流中找出具有最大整数值的所有键。
* 累加器类型 A 为 AbstractMap.SimpleEntry, Integer>。
*/
public static Collector, ?, List> keysToMaximum() {
return Collector.of(
// supplier: 初始化累加器，包含一个空列表和最小整数值
() -> new AbstractMap.SimpleEntry<>(new ArrayList(), Integer.MIN_VALUE),
// accumulator: 处理单个元素
(current, next) -> {
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()); // 添加键
}
},
// combiner: 合并两个累加器
(a, b) -> {
int maxA = a.getValue();
int maxB = b.getValue();
if (maxA < maxB) { // 如果b的最大值更大，返回b
return b;
}
if (maxA == maxB) { // 如果最大值相同，合并键列表
a.getKey().addAll(b.getKey());
}
return a; // 否则返回a
},
// finisher: 返回键列表
Map.Entry::getKey
);
}
public static void main(String[] args) {
Map map = Map.of("A", 10, "B", 20, "C", 15, "D", 20);
List keys = map.entrySet().stream()
.collect(keysToMaximum());
System.out.println("Keys with maximum value: " + keys); // Output: [B, D] (顺序可能不同)
}
} 这里，AbstractMap.SimpleEntry, Integer> 作为累加器，巧妙地存储了两个状态：一个 List
示例四：收集最大值对应的键列表（使用匿名内部类）
如果 AbstractMap.SimpleEntry 的结构不完全符合需求，或者为了更好的封装性，可以使用匿名内部类作为累加器类型。这种方式可以定义任意数量的字段和方法，但其作用域仅限于 Collector.of 内部。
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class KeysToMaximumAnonymousCollector {
/**
* 收集器，用于从 Map.Entry 流中找出具有最大整数值的所有键。
* 累加器类型 A 为一个匿名内部类。
*/
public static Collector, ?, List> keysToMaximum() {
return Collector.of(
// supplier: 创建匿名内部类实例作为累加器
() -> new Object() { // 匿名内部类
int max = Integer.MIN_VALUE;
final List keys = new ArrayList<>();
},
// accumulator: 处理单个元素
(current, next) -> {
int value = next.getValue();
if (value >= current.max) {
if (value > current.max) {
current.max = value;
current.keys.clear();
}
current.keys.add(next.getKey());
}
},
// combiner: 合并两个匿名内部类累加器
(a, b) -> {
if (a.max < b.max) {
return b;
}
if (a.max == b.max) {
a.keys.addAll(b.keys);
}
return a;
},
// finisher: 返回匿名内部类中的 keys 列表
a -> a.keys
);
}
public static void main(String[] args) {
Map map = Map.of("X", 10, "Y", 30, "Z", 20, "W", 30);
List keys = map.entrySet().stream()
.collect(keysToMaximum());
System.out.println("Keys with maximum value (anonymous collector): " + keys); // Output: [Y, W] (顺序可能不同)
}
} 这种方法提供了最大的灵活性，允许我们定义一个完全定制的累加器结构，而无需在文件系统中创建一个新的 .java 文件。
总结与注意事项
通过上述示例，我们可以得出以下关键结论和最佳实践：
- 累加器函数的灵活性：Collector.of 中的 supplier、accumulator、combiner 和 finisher 函数可以使用 Lambda 表达式或方法引用来实现，它们不强制要求作为累加器类型 A 的实例方法。这种分离使得代码更加简洁和模块化。
-
选择合适的累加器类型 A：
- 对于简单的数值累加，考虑使用原生数组（如 int[1]）或 AtomicInteger 等现有工具类。
- 对于需要存储多个相关状态的情况，可以利用 AbstractMap.SimpleEntry 来封装。
- 如果需要更复杂的内部状态或行为，而又不想创建独立的命名类，匿名内部类是强大的选择。
- 何时创建独立的累加器类：只有当累加器的状态非常复杂，并且其内部逻辑（如 accumulate、combine 等）需要被封装成一个可复用的、有明确语义的类时，才考虑创建独立的命名类。在大多数情况下，上述的简化方法已经足够。
- 理解 Collector 特性：根据收集器的行为，正确标记 Collector.Characteristics（如 UNORDERED, CONCURRENT）有助于 Stream API 进行优化。
掌握这些技巧，将使你在自定义 Collector 时更加得心应手，编写出更高效、更简洁、更具可读性的 Java Stream 代码。
