如何在Java Stream中对多个数组执行按元素求和操作？

思路1：利用Stream的reduce操作累加列表 #

通过reduce方法逐个累加每个整数列表，以全0列表作为初始值，每次将当前列表与累加器的对应位置元素相加，最终得到求和结果。

// 定义自定义对象类替代原生Object，避免类型不安全操作
class DataObject {
    private List<Integer> arrayOfInts;

    public DataObject(List<Integer> arrayOfInts) {
        this.arrayOfInts = arrayOfInts;
    }

    public List<Integer> getArrayOfInts() {
        return arrayOfInts;
    }
}

public class SumDemo {
    public static void main(String[] args) {
        DataObject object1 = new DataObject(Arrays.asList(1, 1, 1));
        DataObject object2 = new DataObject(Arrays.asList(2, 2, 2));
        List<DataObject> listOfObjects = Arrays.asList(object1, object2);

        // 前置检查：确保所有列表长度一致
        boolean allSameLength = listOfObjects.stream()
                .map(obj -> obj.getArrayOfInts().size())
                .distinct()
                .count() == 1;
        if (!allSameLength) {
            throw new IllegalArgumentException("所有整数列表长度必须相同");
        }

        // 执行按元素求和
        List<Integer> result = listOfObjects.stream()
                .map(DataObject::getArrayOfInts)
                .reduce(
                    // 初始值：与输入列表长度相同的全0列表
                    listOfObjects.get(0).getArrayOfInts().stream().map(i -> 0).collect(Collectors.toList()),
                    // 累加逻辑：对应位置元素相加
                    (acc, current) -> IntStream.range(0, acc.size())
                            .mapToObj(i -> acc.get(i) + current.get(i))
                            .collect(Collectors.toList())
                )
                .orElse(Collections.emptyList());

        System.out.println(result); // 输出 [3, 3, 3]
    }
}

思路2：按索引遍历求和 #

直接遍历每个元素索引，对所有列表的该索引元素求和，逻辑更直观易懂。

// 承接上述DataObject类和初始化代码
List<Integer> result = IntStream.range(0, listOfObjects.get(0).getArrayOfInts().size())
        .mapToObj(index -> listOfObjects.stream()
                .map(obj -> obj.getArrayOfInts().get(index))
                .reduce(0, Integer::sum))
        .collect(Collectors.toList());

思路3：结合collectingAndThen批量处理 #

先将所有整数列表收集为一个列表集合，再按索引遍历求和，把两步操作合并在流处理中。

// 承接上述DataObject类和初始化代码
List<Integer> result = listOfObjects.stream()
        .map(DataObject::getArrayOfInts)
        .collect(Collectors.collectingAndThen(
                Collectors.toList(),
                lists -> IntStream.range(0, lists.get(0).size())
                        .mapToObj(i -> lists.stream()
                                .mapToInt(list -> list.get(i))
                                .sum())
                        .collect(Collectors.toList())
        ));

注意事项 #

• 必须确保所有对象的整数列表长度一致，否则会抛出索引越界异常，建议添加前置检查。
• 若存在空列表或null对象，需提前用filter过滤，比如filter(obj -> obj.getArrayOfInts() != null)。

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