使用 Java 8 流 API 的累积和

Question

我有一个整数列表，比如 list1，我想获得另一个列表 list2，其中包含从开始到当前索引的累积总和。如何使用 Stream API java 8 做到这一点？

List<Integer> list1 = new ArrayList<>();
list1.addAll(Arrays.asList(1, 2, 3, 4));
List<Integer> list2 = new ArrayList<>();
// initialization
list2.add(list1.get(0));
for(int i=1;i<list1.size();i++) {
// increment step
    list2.add(list2.get(i-1) + list1.get(i));
}

如何将上述命令式代码更改为声明式？

list2 should be [1, 3, 6, 10]

Answer 1

流不适合此类任务，因为涉及到状态（累积部分和）。相反，您可以使用Arrays.parallelPrefix:

Integer[] arr = list1.toArray(Integer[]::new);

Arrays.parallelPrefix(arr, Integer::sum);

List<Integer> list2 = Arrays.asList(arr);

这首先使用Collection.toArray 将list1 复制到一个数组中，该功能从JDK 11 开始提供。如果您还没有使用Java 11，可以将第一行替换为传统的toArray 调用：

Integer[] arr = list1.toArray(new Integer[0]);

此解决方案不使用流，但它是声明性，因为Arrays.parallelPrefix 接收累积运算作为参数（在本例中为Integer::sum）。

时间复杂度为O(N)，尽管可能会涉及一些与设置并行处理所需的基础架构相关的非次要固定成本。但是，根据文档：

并行前缀计算通常比大型数组的顺序循环更有效

所以看来这种方法值得一试。

此外，值得一提的是，这种方法有效，因为Integer::sum 是一个关联操作。这是一个要求。

Answer 2

O(n)（仅按顺序工作）解决方案如下，但我觉得它不是很优雅。我想这是一个品味问题

AtomicInteger ai = new AtomicInteger();
List<Integer> collect = list1.stream()
                             .map(ai::addAndGet)
                             .collect(Collectors.toList());
System.out.println(collect); // [1, 3, 6, 10]

Answer 3

您可以为此使用Stream.collect()：

List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = list1.stream()
        .collect(ArrayList::new, (sums, number) -> {
            if (sums.isEmpty()) {
                sums.add(number);
            } else {
                sums.add(sums.get(sums.size() - 1) + number);
            }
        }, (sums1, sums2) -> {
            if (!sums1.isEmpty()) {
                int sum = sums1.get(sums1.size() - 1);
                sums2.replaceAll(num -> sum + num);
            }
            sums1.addAll(sums2);
        });

此解决方案也适用于并行流。使用list1.parallelStream() 或list1.stream().parallel() 而不是list1.stream()。

两种情况的结果都是：[1, 3, 6, 10]

Answer 4

对于每个索引：从零迭代到该索引，获取每个元素，然后获取总和
将整数装箱到Integers
收集到一个列表

IntStream.range(0, list1.size())
    .map(i -> IntStream.rangeClosed(0, i).map(list1::get).sum())
    .boxed()
    .collect(Collectors.toList());

您每次都将每个数字相加，而不是重复使用之前的累积结果，但是流不适合查看之前迭代的结果。

您可以编写自己的收集器，但在这一点上，老实说，您为什么还要为流而烦恼？

list1.stream()
    .collect(
        Collector.of(
            ArrayList::new,
            (a, b) -> a.add(a.isEmpty() ? b : b + a.get(a.size() - 1)),
            (a, b) -> { throw new UnsupportedOperationException(); }
        )
    );

Answer 5

你可以使用sublist从开始累加到当前索引：

List<Integer> list = IntStream.range(0, list1.size())
        .mapToObj(i -> list1.subList(0, i + 1).stream().mapToInt(Integer::intValue).sum())
        .collect(Collectors.toList());