Java实现：对List内BankDetails的monthMap数组值按月份纵向求和

作为Java新手，咱们一步步拆解这个需求，先从最易懂的循环方式入手，再补充更简洁的Stream写法，保证你能看懂~

先确认BankDetails类的完整定义 #

首先咱们把你提到的POJO类补全getter和setter，方便后续操作：

public class BankDetails {
    private String bankName;
    private Map<String, Long[]> monthMap = new HashMap<>();
    private String month;

    // Getter和Setter方法
    public String getBankName() { return bankName; }
    public void setBankName(String bankName) { this.bankName = bankName; }
    public Map<String, Long[]> getMonthMap() { return monthMap; }
    public void setMonthMap(Map<String, Long[]> monthMap) { this.monthMap = monthMap; }
    public String getMonth() { return month; }
    public void setMonth(String month) { this.month = month; }
}

核心实现思路 #

要完成这个需求，咱们分三步走：

1. 收集所有唯一月份：把所有BankDetails实例里出现过的月份都捞出来，避免重复计算
2. 按月份纵向求和：对每个月份，遍历所有实例，把对应数组的每个元素累加
3. 封装结果实例：把每个月份的总和包装成新的BankDetails对象，组成最终列表

方法一：传统循环实现（新手友好） #

这种写法逻辑直白，适合刚接触Java的同学理解：

import java.util.*;

public class BankSumCalculator {
    public static void main(String[] args) {
        // 模拟你的示例数据
        BankDetails bank1 = new BankDetails();
        Map<String, Long[]> map1 = new HashMap<>();
        map1.put("05", new Long[]{8L, 0L, 0L});
        map1.put("06", new Long[]{6L, 0L, 4L});
        map1.put("07", new Long[]{45L, 3L, 0L});
        map1.put("08", new Long[]{0L, 56L, 9L});
        bank1.setMonthMap(map1);

        BankDetails bank2 = new BankDetails();
        Map<String, Long[]> map2 = new HashMap<>();
        map2.put("05", new Long[]{0L, 0L, 0L});
        map2.put("06", new Long[]{8L, 0L, 4L});
        map2.put("07", new Long[]{5L, 0L, 1L});
        map2.put("08", new Long[]{2L, 6L, 8L});
        bank2.setMonthMap(map2);

        List<BankDetails> inputList = Arrays.asList(bank1, bank2);
        List<BankDetails> resultList = calculateMonthlyTotals(inputList);

        // 打印验证结果
        for (BankDetails total : resultList) {
            System.out.printf("月份%s: 总和数组%s%n", 
                total.getMonth(), Arrays.toString(total.getMonthMap().get(total.getMonth())));
        }
    }

    public static List<BankDetails> calculateMonthlyTotals(List<BankDetails> inputList) {
        // 1. 收集所有唯一月份
        Set<String> allMonths = new HashSet<>();
        for (BankDetails bd : inputList) {
            allMonths.addAll(bd.getMonthMap().keySet());
        }

        List<BankDetails> result = new ArrayList<>();

        // 2. 对每个月份计算总和
        for (String month : allMonths) {
            Long[] totalArray = null;
            // 遍历所有实例累加数组元素
            for (BankDetails bd : inputList) {
                Long[] currentArray = bd.getMonthMap().get(month);
                if (currentArray != null) {
                    // 第一次遇到该月份，初始化总和数组为全0
                    if (totalArray == null) {
                        totalArray = new Long[currentArray.length];
                        Arrays.fill(totalArray, 0L);
                    }
                    // 逐个元素相加
                    for (int i = 0; i < currentArray.length; i++) {
                        totalArray[i] += currentArray[i];
                    }
                }
            }

            // 3. 封装成新的BankDetails实例
            BankDetails totalBD = new BankDetails();
            totalBD.setMonth(month);
            totalBD.setBankName("月度总计"); // 可自定义名称
            Map<String, Long[]> totalMap = new HashMap<>();
            totalMap.put(month, totalArray);
            totalBD.setMonthMap(totalMap);

            result.add(totalBD);
        }

        // 可选：按月份排序，让结果更整齐
        result.sort(Comparator.comparing(BankDetails::getMonth));
        return result;
    }
}

方法二：Java 8 Stream简化实现 #

如果你已经对Stream有初步了解，可以用这种更简洁的写法：

import java.util.*;
import java.util.stream.Collectors;

public class BankSumStreamCalculator {
    public static List<BankDetails> calculateMonthlyTotalsWithStream(List<BankDetails> inputList) {
        return inputList.stream()
                // 把每个实例的monthMap拆成（月份，数组）的键值对流
                .flatMap(bd -> bd.getMonthMap().entrySet().stream())
                // 按月份分组
                .collect(Collectors.groupingBy(Map.Entry::getKey))
                .entrySet().stream()
                // 对每个月份的数组列表求和
                .map(entry -> {
                    String month = entry.getKey();
                    List<Long[]> arrays = entry.getValue().stream()
                            .map(Map.Entry::getValue)
                            .collect(Collectors.toList());
                    
                    // 计算总和数组
                    Long[] totalArray = new Long[arrays.get(0).length];
                    Arrays.fill(totalArray, 0L);
                    for (Long[] arr : arrays) {
                        for (int i = 0; i < arr.length; i++) {
                            totalArray[i] += arr[i];
                        }
                    }

                    // 封装结果实例
                    BankDetails totalBD = new BankDetails();
                    totalBD.setMonth(month);
                    totalBD.setBankName("月度总计");
                    Map<String, Long[]> totalMap = new HashMap<>();
                    totalMap.put(month, totalArray);
                    totalBD.setMonthMap(totalMap);
                    return totalBD;
                })
                // 按月份排序
                .sorted(Comparator.comparing(BankDetails::getMonth))
                .collect(Collectors.toList());
    }
}

注意事项 #

• 假设所有同月份的数组长度一致，如果遇到长度不同的情况，可以额外处理（比如抛出异常或补0）
• 数组元素是Long类型，初始化时要用0L避免int/Long类型冲突
• 结果里的bankName可以根据你的需求自定义，比如改成“各银行合计”之类的

内容的提问来源于stack exchange，提问作者Student