Java Stream API：高效聚合Map值并处理重复键的累加逻辑

import java.math.BigDecimal;
import java.util.Objects;

// 用于Map的键
private static 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 + '\'' +
               '}';
    }
}

// 原始数据对象
private static class Position {
    Long portfolioId;
    String assetId;
    String currencyId;
    BigDecimal value;

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

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

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import static java.util.stream.Collectors.toMap;

public class PositionAggregator {

    // 模拟获取Position列表的方法
    private List<Position> getPositions(final Long portfolioId) {
        // 实际应用中会从数据库或其他数据源获取
        return List.of(
            new Position(portfolioId, "AAPL", "USD", new BigDecimal("100.50")),
            new Position(portfolioId, "GOOG", "USD", new BigDecimal("200.75")),
            new Position(portfolioId, "AAPL", "USD", new BigDecimal("50.25")), // 重复键
            new Position(portfolioId, "MSFT", "EUR", new BigDecimal("150.00"))
        );
    }

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

        return getPositions(portfolioId).stream()
            .collect(
                toMap(
                    position ->
                        new PositionKey(
                            position.getAssetId(),
                            position.getCurrencyId()),
                    position -> position.getValue(),
                    (oldValue, newValue) -> oldValue != null ? oldValue.add(newValue) : newValue, // 合并函数
                    () -> map)); // 将预先创建的Map作为工厂
    }
}

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import static java.util.stream.Collectors.toMap;

public class PositionAggregatorOptimized {

    // ... (PositionKey 和 Position 类定义同上) ...

    private List<Position> getPositions(final Long portfolioId) {
        return List.of(
            new Position(portfolioId, "AAPL", "USD", new BigDecimal("100.50")),
            new Position(portfolioId, "GOOG", "USD", new BigDecimal("200.75")),
            new Position(portfolioId, "AAPL", "USD", new BigDecimal("50.25")),
            new Position(portfolioId, "MSFT", "EUR", new BigDecimal("150.00"))
        );
    }

    /**
     * 使用Java Stream API聚合Position数据到Map，并累加重复键的值。
     * 采用HashMap::new作为Map工厂，实现更简洁、函数式。
     *
     * @param portfolioId 投资组合ID
     * @return 聚合后的Map<PositionKey, BigDecimal>
     */
    public Map<PositionKey, BigDecimal> getAggregatedPositionMap(final Long portfolioId) {
        return getPositions(portfolioId).stream()
            .collect(
                toMap(
                    position -> new PositionKey(
                        position.getAssetId(),
                        position.getCurrencyId()),
                    position -> position.getValue(),
                    // 合并函数：BigDecimal是不可变的，add方法返回一个新的BigDecimal实例
                    (oldValue, newValue) -> oldValue.add(newValue),
                    // Map工厂：每次收集时创建一个新的HashMap实例
                    HashMap::new)); // 推荐使用方法引用
                    // 或者使用Lambda表达式: () -> new HashMap<>()
    }

    public static void main(String[] args) {
        PositionAggregatorOptimized aggregator = new PositionAggregatorOptimized();
        Long testPortfolioId = 123L;
        Map<PositionKey, BigDecimal> result = aggregator.getAggregatedPositionMap(testPortfolioId);

        System.out.println("聚合结果:");
        result.forEach((key, value) -> System.out.println(key + " -> " + value));

        // 预期输出:
        // PositionKey{assetId='GOOG', currencyId='USD'} -> 200.75
        // PositionKey{assetId='MSFT', currencyId='EUR'} -> 150.00
        // PositionKey{assetId='AAPL', currencyId='USD'} -> 150.75 (100.50 + 50.25)
    }
}