本文深入探讨Java Collector的自定义实现，重点关注如何灵活选择和设计累加器（Accumulator）类型。通过多种示例，包括使用基本数组、AtomicInteger、AbstractMap.SimpleEntry以及匿名内部类，展示了在不创建额外具名类的情况下构建高效且简洁的Collector的方法，强调了Collector.of在函数式编程中的强大应用。
理解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，我们想找出所有对应值为最大Integer的键。
import java.util.*;import java.util.stream.Collector;import java.util.stream.Collectors;public class CustomCollectors { /** * 创建一个Collector，用于从Map.Entry流中收集所有具有最大值的键。 * 累加器类型使用AbstractMap.SimpleEntry<List, Integer>。 */ public static Collector<Map.Entry, ?, 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 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<Map.Entry, ?, 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
以上就是Java Collector自定义实现：灵活选择累加器类型的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/66484.html
微信扫一扫 
支付宝扫一扫 
