Java Stream如何聚合Map键值求和

本文深入探讨了如何利用Java Stream API中的`Collectors.toMap`方法，高效地将数据流转换为Map。核心内容是演示如何在键冲突时，通过自定义合并函数对BigDecimal类型的值进行累加求和，并强调了使用`HashMap::new`作为Map工厂的正确实践，以确保代码的简洁性和封装性，避免外部Map的预先创建。

在Java开发中，将一个对象集合转换为Map是一种常见操作。尤其当转换过程中可能出现键冲突，并且需要对冲突键的值进行聚合（例如求和）时，Java Stream API提供了强大而灵活的解决方案。本文将详细介绍如何使用Collectors.toMap结合自定义合并函数和Map工厂，实现对Map中现有键的值进行累加求和。

场景描述

假设我们有一个Position对象的列表，每个Position对象包含assetId、currencyId和value（BigDecimal类型）。我们需要将这些Position对象转换为一个Map，其中PositionKey由assetId和currencyId组合而成。如果不同的Position对象生成了相同的PositionKey，那么它们的value应该被累加到Map中该键对应的BigDecimal值上。

为了清晰地演示，我们首先定义相关的辅助类：

import java.math.BigDecimal;
import java.util.Objects;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.stream.Collectors;

// 组合键类
class PositionKey {
    String assetId;
    String currencyId;

    public PositionKey(String assetId, String currencyId) {
        this.assetId = assetId;
        this.currencyId = currencyId;
    }

    // 必须重写equals和hashCode，确保Map的键能够正确比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PositionKey that = (PositionKey) o;
        return Objects.equals(assetId, that.assetId) &&
               Objects.equals(currencyId, that.currencyId);
    }

    @Override
    public int hashCode() {
        return Objects.hash(assetId, currencyId);
    }

    @Override
    public String toString() {
        return "PositionKey{" +
               "assetId='" + assetId + '\'' +
               ", currencyId='" + currencyId + '\'' +
               '}';
    }
}

// 持仓对象类
class Position {
    String assetId;
    String currencyId;
    BigDecimal value;

    public Position(String assetId, String currencyId, BigDecimal value) {
        this.assetId = assetId;
        this.currencyId = currencyId;
        this.value = value;
    }

    public String getAssetId() { return assetId; }
    public String getCurrencyId() { return currencyId; }
    public BigDecimal getValue() { return value; }

    @Override
    public String toString() {
        return "Position{" +
               "assetId='" + assetId + '\'' +
               ", currencyId='" + currencyId + '\'' +
               ", value=" + value +
               '}';
    }
}

使用Collectors.toMap进行聚合

Collectors.toMap方法有多个重载形式，其中一个非常适用于我们当前场景的是： public static > Collector toMap(Function keyMapper, Function valueMapper, BinaryOperator mergeFunction, Supplier mapFactory)

• keyMapper: 用于从流元素中提取键的函数。
• valueMapper: 用于从流元素中提取值的函数。
• mergeFunction: 当两个流元素映射到相同的键时，用于解决值冲突的函数。
• mapFactory: 一个提供新的空Map实例的工厂函数（Supplier）。

初始尝试与改进空间

在一些初次尝试中，开发者可能会先创建一个空的HashMap，然后将其作为mapFactory传递给Collectors.toMap，如下所示：

public class PositionAggregator {

    // 模拟获取持仓数据的方法
    private List getPositions(Long portfolioId) {
        List positions = new ArrayList<>();
        positions.add(new Position("AAPL", "USD", new BigDecimal("100.50")));
        positions.add(new Position("GOOG", "USD", new BigDecimal("200.00")));
        positions.add(new Position("AAPL", "USD", new BigDecimal("50.25"))); // 相同键，需要累加
        positions.add(new Position("MSFT", "EUR", new BigDecimal("120.75")));
        positions.add(new Position("GOOG", "USD", new BigDecimal("75.00"))); // 相同键，需要累加
        return positions;
    }

    public Map getAggregatedMap(final Long portfolioId) {
        final Map map = new HashMap<>(); // 预先创建Map

        return getPositions(portfolioId).stream()
            .collect(
                Collectors.toMap(
                    position -> new PositionKey(position.getAssetId(), position.getCurrencyId()), // keyMapper
                    Position::getValue, // valueMapper
                    (oldValue, newValue) -> oldValue.add(newValue), // mergeFunction
                    () -> map // mapFactory，引用外部已创建的Map
                ));
    }
}

虽然上述代码能够实现功能，但() -> map这种形式将一个外部已创建的Map实例传递给Collectors.toMap作为工厂，这在语义上略显不当。mapFactory的目的是提供一个 新的 空Map实例，供收集器内部使用。直接引用外部Map虽然在此特定情况下可能不会导致错误（因为toMap会清空它或直接使用它），但最佳实践是让收集器完全负责Map的创建。

最佳实践：使用HashMap::new作为Map工厂

为了遵循Stream API的函数式编程范式并提高代码的清晰度，我们应该提供一个真正能够创建新HashMap实例的Supplier。最简洁和推荐的方式是使用方法引用HashMap::new。

public class PositionAggregator {

    // 模拟获取持仓数据的方法
    private List getPositions(Long portfolioId) {
        List positions = new ArrayList<>();
        positions.add(new Position("AAPL", "USD", new BigDecimal("100.50")));
        positions.add(new Position("GOOG", "USD", new BigDecimal("200.00")));
        positions.add(new Position("AAPL", "USD", new BigDecimal("50.25"))); // 相同键，需要累加
        positions.add(new Position("MSFT", "EUR", new BigDecimal("120.75")));
        positions.add(new Position("GOOG", "USD", new BigDecimal("75.00"))); // 相同键，需要累加
        return positions;
    }

    /**
     * 使用Java Stream和Collectors.toMap高效聚合持仓数据。
     * 当PositionKey冲突时，对BigDecimal值进行累加。
     *
     * @param portfolioId 投资组合ID
     * @return 聚合后的Map
     */
    public Map getAggregatedPositionsMap(final Long portfolioId) {
        return getPositions(portfolioId).stream()
            .collect(
                Collectors.toMap(
                    position -> new PositionKey(position.getAssetId(), position.getCurrencyId()), // 键映射函数
                    Position::getValue, // 值映射函数
                    (oldValue, newValue) -> oldValue.add(newValue), // 合并函数：BigDecimal累加
                    HashMap::new // Map工厂：提供新的HashMap实例
                ));
    }

    public static void main(String[] args) {
        PositionAggregator aggregator = new PositionAggregator();
        Map aggregatedMap = aggregator.getAggregatedPositionsMap(123L);

        System.out.println("聚合后的持仓Map:");
        aggregatedMap.forEach((key, value) -> System.out.println(key + " -> " + value));

        // 预期输出示例:
        // PositionKey{assetId='AAPL', currencyId='USD'} -> 150.75
        // PositionKey{assetId='GOOG', currencyId='USD'} -> 275.00
        // PositionKey{assetId='MSFT', currencyId='EUR'} -> 120.75
    }
}

合并函数详解：BinaryOperator mergeFunction

在上述代码中，mergeFunction被定义为 (oldValue, newValue) -> oldValue.add(newValue)。这个Lambda表达式的含义是：

• 当Collectors.toMap尝试将一个新值放入Map，但发现该键已经存在时，它会调用此合并函数。
• oldValue是Map中该键当前存储的值。
• newValue是当前流元素映射到的新值。
• 函数返回的结果将替换Map中该键的旧值。

对于BigDecimal类型，我们必须使用其add()方法进行数值相加，而不是使用+运算符（因为BigDecimal是对象，+运算符不适用于它）。原始问题中的oldValue != null ? oldValue.add(newValue) : newValue是一个更健壮的写法，它考虑了oldValue可能为null的情况。然而，在大多数实际应用中，如果valueMapper（Position::getValue）始终返回非null的BigDecimal，并且Map中初始值也是非null的，那么oldValue就不会是null，此时直接使用oldValue.add(newValue)是安全且简洁的。如果你的数据源确实可能产生null的BigDecimal值，那么加上null检查会更安全。

注意事项与总结

1. equals()和hashCode()的正确实现：作为Map的键，PositionKey类必须正确重写equals()和hashCode()方法。这是Map正确识别和处理键冲突的基础。
2. BigDecimal的精确计算：使用BigDecimal进行金融计算是最佳实践，因为它提供了精确的浮点数运算，避免了double或float带来的精度问题。务必使用其提供的add()、subtract()等方法进行运算。
3. mapFactory的选择：HashMap::new是创建默认HashMap的简洁方式。如果你需要一个特定类型的Map（例如TreeMap用于排序键，或ConcurrentHashMap用于并发环境），你可以提供相应的Supplier，例如TreeMap::new。
4. 流式操作的优势：使用Stream API可以使数据处理逻辑更加声明式、简洁和易读。它将“做什么”与“如何做”分离，提高了代码的可维护性。

通过以上方法，我们可以利用Java Stream API强大而灵活的Collectors.toMap，以一种优雅且高效的方式，将数据流转换为Map，并根据业务需求对冲突键的值进行聚合。这种模式在处理各种数据转换和汇总任务时都非常有用。