在java开发中，我们经常会遇到需要处理包含重复元素的列表，并对这些重复元素进行数据聚合的场景。例如，一个商品订单列表，其中包含多个相同商品的条目，但我们希望汇总每个商品的购买数量和总金额。直接通过循环遍历和手动比较来处理这种需求，不仅代码冗长，而且效率低下，容易出错。本文将介绍两种更优雅、更高效的解决方案：利用hashmap进行逐个聚合，以及使用java 8引入的stream api进行声明式聚合。
1. 场景分析与问题定义
假设我们有一个包含以下类型元素的列表：
class Data {
String type;
Double amount;
Integer quantity;
public Data(String type, Double amount, Integer quantity) {
this.type = type;
this.amount = amount;
this.quantity = quantity;
}
public String getType() { return type; }
public Double getAmount() { return amount; }
public Integer getQuantity() { return quantity; }
@Override
public String toString() {
return "Data{" +
"type='" + type + '\'' +
", amount=" + amount +
", quantity=" + quantity +
'}';
}
}初始列表数据可能如下：
Type: Type A, Amount : 55.0, Quantity : 0 Type: Type A, Amount : 55.0, Quantity : 5 Type: Type A, Amount : 44.35, Quantity : 6 Type: Type A, Amount : 55.0, Quantity : 0 Type: Type B, Amount : 7.0, Quantity : 1 Type: Type B, Amount : 7.0, Quantity : 1 Type: Type C, Amount : 1613.57, Quantity : 0 Type: Type C, Amount : 1613.57, Quantity : 1
我们的目标是根据 Type 字段识别重复元素，并将相同 Type 的 Amount 和 Quantity 进行累加，最终得到一个聚合后的列表，例如：
Type: Type A, Amount : 209.35, Quantity : 11 Type: Type B, Amount : 14.0, Quantity : 2 Type: Type C, Amount : 3227.14, Quantity : 1
2. 优化数据模型
在进行数据聚合时，通常我们会将原始数据的一部分作为键（Key），另一部分作为值（Value）。为了更好地表示聚合后的数据，我们可以定义一个专门的聚合数据结构。在Java 14及以上版本中，record 类型提供了一种简洁的方式来定义不可变的数据载体，非常适合此类场景。
立即学习“Java免费学习笔记（深入）”；
// 原始数据模型（为方便示例，这里使用record，与Data类等效）
record OriginalData(String type, Double amount, Integer quantity) {}
// 聚合后的数据模型
record AggregatedData(Double amount, Integer quantity) {}AggregatedData 将用于存储每个 Type 对应的累加金额和数量。
3. 解决方案一：使用 HashMap 进行逐个聚合
HashMap 是一个非常适合进行键值对存储的数据结构，它天然地保证了键的唯一性。我们可以将元素的 Type 作为 HashMap 的键，将聚合后的 AggregatedData 作为值。当遇到重复的 Type 时，我们只需更新其对应的值即可。
HashMap 的 compute 方法是实现这一逻辑的理想选择。compute 方法允许我们根据键的值进行计算并更新，如果键不存在则插入新值，如果键存在则根据旧值计算新值。
3.1 compute 方法详解
compute(K key, BiFunction super K, ? super V, ? extends V> remappingFunction) 方法会尝试计算指定键的新映射。
- key: 要计算或更新的键。
- remappingFunction: 一个双参数函数，接收键和当前值（如果存在，否则为null），并返回新的值。如果返回null，则表示删除该键的映射。
3.2 代码示例
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MapAggregationExample {
// 原始数据模型
record OriginalData(String type, Double amount, Integer quantity) {}
// 聚合后的数据模型
record AggregatedData(Double amount, Integer quantity) {}
public static void main(String[] args) {
List originalList = List.of(
new OriginalData("Type A", 55.0, 0),
new OriginalData("Type A", 55.0, 5),
new OriginalData("Type A", 44.35, 6),
new OriginalData("Type A", 55.0, 0),
new OriginalData("Type B", 7.0, 1),
new OriginalData("Type B", 7.0, 1),
new OriginalData("Type C", 1613.57, 0),
new OriginalData("Type C", 1613.57, 1)
);
Map aggregatedMap = new HashMap<>();
for (OriginalData data : originalList) {
aggregatedMap.compute(data.type(), (key, existingAggregatedData) -> {
if (existingAggregatedData == null) {
// 如果是第一次遇到这个Type，则创建新的AggregatedData
return new AggregatedData(data.amount(), data.quantity());
} else {
// 如果Type已存在，则累加金额和数量
return new AggregatedData(
existingAggregatedData.amount() + data.amount(),
existingAggregatedData.quantity() + data.quantity()
);
}
});
}
System.out.println("使用HashMap聚合结果:");
aggregatedMap.forEach((type, aggData) ->
System.out.printf("Type: %s, Amount : %.2f, Quantity : %d%n",
type, aggData.amount(), aggData.quantity()));
}
} 输出：
使用HashMap聚合结果: Type: Type A, Amount : 209.35, Quantity : 11 Type: Type B, Amount : 14.00, Quantity : 2 Type: Type C, Amount : 3227.14, Quantity : 1
注意事项：
- compute 方法的第二个参数是一个 BiFunction，它接收当前键和与该键关联的当前值。如果键不存在，当前值为 null。
- 在函数内部，我们检查 existingAggregatedData 是否为 null 来判断是首次插入还是更新。
- AggregatedData 被设计为不可变记录，每次更新都返回一个新的 AggregatedData 实例，这符合函数式编程的理念，并有助于避免副作用。
4. 解决方案二：利用 Stream API 和 Collectors.toMap
Java 8 引入的 Stream API 提供了一种更声明式、更简洁的方式来处理集合数据。对于聚合操作，Collectors.toMap 方法结合一个合并函数（merge function）是理想的选择。
4.1 Collectors.toMap 方法详解
Collectors.toMap(keyMapper, valueMapper, mergeFunction) 方法用于将流中的元素收集到一个 Map 中。
- keyMapper: 一个函数，用于从流元素中提取键。
- valueMapper: 一个函数，用于从流元素中提取值。
- mergeFunction: 一个双参数函数，用于处理当两个流元素映射到同一个键时如何合并它们的值。这是解决重复元素累加的关键。
4.2 代码示例
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class StreamAggregationExample {
// 原始数据模型
record OriginalData(String type, Double amount, Integer quantity) {}
// 聚合后的数据模型
record AggregatedData(Double amount, Integer quantity) {}
public static void main(String[] args) {
List originalList = List.of(
new OriginalData("Type A", 55.0, 0),
new OriginalData("Type A", 55.0, 5),
new OriginalData("Type A", 44.35, 6),
new OriginalData("Type A", 55.0, 0),
new OriginalData("Type B", 7.0, 1),
new OriginalData("Type B", 7.0, 1),
new OriginalData("Type C", 1613.57, 0),
new OriginalData("Type C", 1613.57, 1)
);
Map aggregatedMap = originalList.stream()
.collect(Collectors.toMap(
OriginalData::type, // keyMapper: 使用Type作为键
data -> new AggregatedData(data.amount(), data.quantity()), // valueMapper: 初始值
(existingAggregatedData, newAggregatedData) -> // mergeFunction: 合并函数
new AggregatedData(
existingAggregatedData.amount() + newAggregatedData.amount(),
existingAggregatedData.quantity() + newAggregatedData.quantity()
)
));
System.out.println("使用Stream API聚合结果:");
aggregatedMap.forEach((type, aggData) ->
System.out.printf("Type: %s, Amount : %.2f, Quantity : %d%n",
type, aggData.amount(), aggData.quantity()));
}
} 输出：
使用Stream API聚合结果: Type: Type A, Amount : 209.35, Quantity : 11 Type: Type B, Amount : 14.00, Quantity : 2 Type: Type C, Amount : 3227.14, Quantity : 1
注意事项：
- keyMapper 提取 OriginalData 的 type 作为 Map 的键。
- valueMapper 将 OriginalData 转换为 AggregatedData 作为 Map 的值。这里需要注意，每个 OriginalData 都会被映射成一个新的 AggregatedData 实例。
- mergeFunction 是核心。当两个 OriginalData 实例生成了相同的键时，此函数会被调用，它接收两个 AggregatedData（旧值和新值），然后返回一个合并后的新 AggregatedData。
5. 总结与最佳实践
本文详细介绍了两种在Java中高效处理列表重复元素数值累加的方法：
- 使用 HashMap 的 compute 方法：适用于需要逐个处理元素，或者在循环中进行复杂逻辑判断的场景。它提供了细粒度的控制，但代码相对更命令式。
- 使用 Stream API 的 Collectors.toMap 方法：适用于声明式的数据转换和聚合。它使代码更加简洁、易读，尤其是在处理大量数据时，其并行流的特性可能带来性能优势。
选择建议：
- 对于Java 8及更高版本，通常推荐使用 Stream API 的方式，因为它更符合现代Java的编程范式，代码更简洁、可读性更强。
- 如果你的项目还在使用旧版Java，或者聚合逻辑非常复杂，需要更多中间步骤和条件判断，HashMap 的 compute 方法可能提供更好的灵活性。
无论选择哪种方法，设计一个清晰的聚合数据模型（如 AggregatedData）都是一个良好的实践，它能使代码更具可读性和可维护性。同时，利用 record 类型可以进一步简化数据模型的定义。
