理解Java Collector及其核心组件
在Java Stream API中，Collector是一个强大的接口，用于将流中的元素聚合成一个最终结果。Stream.collect()方法接收一个Collector实例，该实例定义了聚合过程的四个关键阶段：供应（supply）、累加（accumulate）、合并（combine）和完成（finish）。
Collector接口有三个泛型类型：Collector
- T：流中元素的类型。
- A：累加器（Accumulator）的类型，即在累加过程中用于存储中间结果的可变容器。这个类型通常是内部实现细节，对外不直接暴露。
- R：最终结果的类型。
自定义Collector最常用的方式是使用Collector.of()静态工厂方法，它接受以下函数式接口作为参数：
- supplier(): 一个Supplier，负责创建新的累加器实例。
- accumulator(): 一个BiConsumer，负责将流中的单个元素T累加到累加器A中。
- combiner(): 一个BinaryOperator，负责将两个累加器A合并成一个（主要用于并行流）。
- finisher(): 一个Function（可选），负责将累加器A转换为最终结果R。如果累加器类型A与最终结果类型R相同，则可以省略此参数。
- characteristics(): 一个Set
（可选），描述Collector的行为特性，如UNORDERED（元素顺序不重要）、CONCURRENT（支持并发累加）、IDENTITY_FINISH（累加器就是最终结果）。
在实践中，许多开发者可能会认为需要为累加器类型A专门创建一个具名类。然而，Collector.of()的强大之处在于，它的参数都是函数式接口，这意味着我们可以直接使用Lambda表达式、方法引用，甚至匿名内部类来定义这些行为，从而极大地简化了代码，并且累加器类型A并不强制要求是一个独立的具名类。
立即学习“Java免费学习笔记（深入）”；
灵活选择累加器类型（A）的策略
累加器类型A的选择是自定义Collector的关键。以下将通过具体示例展示几种常见的累加器类型选择策略。
1. 使用基本数组作为简单累加器
对于只需要累加一个简单值（如总和、计数）的场景，一个单元素的数组（例如int[1]）是简洁且高效的累加器类型。它直接操作基本类型，内存开销小。
示例：计算流中整数的总和
import java.util.stream.Collector;
import java.util.stream.Stream;
public class CustomCollectors {
/**
* 创建一个Collector，用于计算Integer流的总和。
* 累加器类型使用int[1]。
*/
public static Collector sumIntegers() {
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: 合并两个数组，将b的值加到a
a -> a[0], // finisher: 返回数组的第一个位置的值作为最终结果
Collector.Characteristics.UNORDERED // 标识该收集器处理顺序不重要
);
}
public static void main(String[] args) {
Integer totalSum = Stream.of(1, 2, 3, 4, 5)
.collect(sumIntegers());
System.out.println("Sum using int[1] collector: " + totalSum); // Output: 15
}
} 注意事项： 数组是可变对象，其内部状态直接被修改。在并行流中，combiner函数负责正确合并不同线程的累加结果。
2. 利用现有可变类型作为累加器
Java标准库中已经包含了一些可变的容器类型，它们可以直接用作累加器，特别是在需要线程安全或特定操作时。
示例：使用AtomicInteger计算流中整数的总和
AtomicInteger提供了原子操作，非常适合在并发环境中作为累加器。
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collector;
import java.util.stream.Stream;
public class CustomCollectors {
/**
* 创建一个Collector，用于计算Integer流的总和。
* 累加器类型使用AtomicInteger。
*/
public static Collector sumWithAtomicInteger() {
return Collector.of(
AtomicInteger::new, // supplier: 创建一个新的AtomicInteger实例
AtomicInteger::addAndGet, // accumulator: 使用addAndGet方法原子性地累加元素
(a, b) -> { a.addAndGet(b.intValue()); return a; }, // combiner: 将b的值原子性地加到a
AtomicInteger::intValue, // finisher: 返回AtomicInteger的int值
Collector.Characteristics.UNORDERED, // 顺序不重要
Collector.Characteristics.CONCURRENT // 标识该收集器是并发安全的
);
}
public static void main(String[] args) {
Integer totalSum = Stream.of(1, 2, 3, 4, 5)
.collect(sumWithAtomicInteger());
System.out.println("Sum using AtomicInteger collector: " + totalSum); // Output: 15
}
} 注意事项： 选择合适的现有类型，并理解其行为特性，例如AtomicInteger的并发安全性。Collector.Characteristics.CONCURRENT标志表明该Collector可以在并发模式下安全地执行累加操作。
3. 复合累加器：使用标准库数据结构
当累加器需要存储多个相关但不同类型的值时，可以利用如Map.Entry（或AbstractMap.SimpleEntry）等标准库数据结构来封装这些状态。
示例：从Map条目流中收集具有最大值的键
假设有一个Map
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class CustomCollectors {
/**
* 创建一个Collector，用于从Map.Entry流中收集所有具有最大值的键。
* 累加器类型使用AbstractMap.SimpleEntry, Integer>。
*/
public static Collector, ?, List> keysToMaximum() {
return Collector.of(
// supplier: 创建一个SimpleEntry，存储键列表和当前最大值
() -> new AbstractMap.SimpleEntry<>(new ArrayList(), Integer.MIN_VALUE),
// accumulator: 将当前元素累加到SimpleEntry中
(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: 合并两个SimpleEntry累加器
(a, b) -> {
int maxA = a.getValue();
int maxB = b.getValue();
if (maxA < maxB) return b; // b的max更大，取b
if (maxA > maxB) return a; // a的max更大，取a
// maxA == maxB，合并键列表
a.getKey().addAll(b.getKey());
return a;
},
Map.Entry::getKey // finisher: 返回SimpleEntry中的键列表
);
}
public static void main(String[] args) {
Map scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 95);
scores.put("Charlie", 90);
scores.put("David", 95);
List maxScoreKeys = scores.entrySet().stream()
.collect(keysToMaximum());
System.out.println("Keys with maximum score: " + maxScoreKeys); // Output: [Bob, David] (顺序可能不同)
}
} 注意事项： AbstractMap.SimpleEntry是可变的，其键和值本身也可以是可变的（如ArrayList），需要谨慎处理其内部状态的修改。
4. 使用匿名内部类或Ad-hoc类型作为累加器
当累加逻辑比较复杂，或者需要封装多个私有状态且不希望这些状态在Collector外部可见时，可以使用匿名内部类来定义一个临时的、仅在Collector内部可见的累加器类型。这种方式提供了很好的封装性，避免了创建额外的具名类文件。
示例：使用匿名内部类收集具有最大值的键
与上一个示例相同的功能，但累加器类型使用匿名内部类定义。
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class CustomCollectors {
/**
* 创建一个Collector，用于从Map.Entry流中收集所有具有最大值的键。
* 累加器类型使用匿名内部类。
*/
public static Collector, ?, List> keysToMaximumAdHoc() {
return Collector.of(
// supplier: 定义一个匿名内部类作为累加器，封装max值和keys列表
() -> new Object() {
int max = Integer.MIN_VALUE;
final List keys = new ArrayList<>();
},
// accumulator: 将当前元素累加到匿名内部类实例中
(current, next) -> {
int value 
