在Java Stream API中，Collector是一个强大的接口，用于将流中的元素聚合成一个最终结果。Stream.collect()方法接收一个Collector实例，该实例定义了聚合过程的四个关键阶段：供应（supply）、累加（accumulate）、合并（combine）和完成（finish）。
Collector接口有三个泛型类型：Collector<T, A, R>：
自定义Collector最常用的方式是使用Collector.of()静态工厂方法，它接受以下函数式接口作为参数：
在实践中，许多开发者可能会认为需要为累加器类型A专门创建一个具名类。然而，Collector.of()的强大之处在于，它的参数都是函数式接口，这意味着我们可以直接使用Lambda表达式、方法引用，甚至匿名内部类来定义这些行为，从而极大地简化了代码，并且累加器类型A并不强制要求是一个独立的具名类。
立即学习“Java免费学习笔记（深入）”；
累加器类型A的选择是自定义Collector的关键。以下将通过具体示例展示几种常见的累加器类型选择策略。
对于只需要累加一个简单值（如总和、计数）的场景，一个单元素的数组（例如int[1]）是简洁且高效的累加器类型。它直接操作基本类型，内存开销小。
示例：计算流中整数的总和
import java.util.stream.Collector;
import java.util.stream.Stream;
public class CustomCollectors {
/**
* 创建一个Collector，用于计算Integer流的总和。
* 累加器类型使用int[1]。
*/
public static Collector<Integer, ?, Integer> 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函数负责正确合并不同线程的累加结果。
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<Integer, ?, Integer> 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可以在并发模式下安全地执行累加操作。
当累加器需要存储多个相关但不同类型的值时，可以利用如Map.Entry（或AbstractMap.SimpleEntry）等标准库数据结构来封装这些状态。
示例：从Map条目流中收集具有最大值的键
假设有一个Map<K, Integer>，我们想找出所有对应值为最大Integer的键。
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class CustomCollectors {
/**
* 创建一个Collector，用于从Map.Entry<K, Integer>流中收集所有具有最大值的键。
* 累加器类型使用AbstractMap.SimpleEntry<List<K>, Integer>。
*/
public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximum() {
return Collector.of(
// supplier: 创建一个SimpleEntry，存储键列表和当前最大值
() -> new AbstractMap.SimpleEntry<>(new ArrayList<K>(), 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<String, Integer> scores = new HashMap<>();
scores.put("Alice", 90);
scores.put("Bob", 95);
scores.put("Charlie", 90);
scores.put("David", 95);
List<String> maxScoreKeys = scores.entrySet().stream()
.collect(keysToMaximum());
System.out.println("Keys with maximum score: " + maxScoreKeys); // Output: [Bob, David] (顺序可能不同)
}
}注意事项： AbstractMap.SimpleEntry是可变的，其键和值本身也可以是可变的（如ArrayList），需要谨慎处理其内部状态的修改。
当累加逻辑比较复杂，或者需要封装多个私有状态且不希望这些状态在Collector外部可见时，可以使用匿名内部类来定义一个临时的、仅在Collector内部可见的累加器类型。这种方式提供了很好的封装性，避免了创建额外的具名类文件。
示例：使用匿名内部类收集具有最大值的键
与上一个示例相同的功能，但累加器类型使用匿名内部类定义。
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public class CustomCollectors {
/**
* 创建一个Collector，用于从Map.Entry<K, Integer>流中收集所有具有最大值的键。
* 累加器类型使用匿名内部类。
*/
public static <K> Collector<Map.Entry<K, Integer>, ?, List<K>> keysToMaximumAdHoc() {
return Collector.of(
// supplier: 定义一个匿名内部类作为累加器，封装max值和keys列表
() -> new Object() {
int max = Integer.MIN_VALUE;
final List<K> keys = new ArrayList<>();
},
// accumulator: 将当前元素累加到匿名内部类实例中
(current, next) -> {
int value以上就是Java Collector自定义实现：灵活选择累加器类型的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
944
收藏
