高效处理Java列表中重复元素的数值累加：Map与Stream API详解-java教程-PHP中文网

高效处理Java列表中重复元素的数值累加：Map与Stream API详解

本教程旨在解决Java列表中重复元素值累加的问题。当列表包含具有相同标识（如Type）的元素时，需要将它们的数值（如Amount和Quantity）合并。我们将探讨两种高效且专业的解决方案：利用HashMap的compute方法进行逐个处理，以及使用Java Stream API的Collectors.toMap方法进行声明式聚合，确保数据处理的准确性和效率。

在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<OriginalData> 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<String, AggregatedData> 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()));
    }
}

登录后复制

输出：

降重鸟

要想效果好，就用降重鸟。AI改写智能降低AIGC率和重复率。

113

查看详情

使用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<OriginalData> 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<String, AggregatedData> 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 方法：适用于声明式的数据转换和聚合。它使代码更加简洁、易读，尤其是在处理大量数据时，其并行流的特性可能带来性能优势。

选择建议：