汇总列表中的每N个元素？

Question

我有一个这样的数字列表：

[ 0, 1, 2, 3, 4, 5, 6, 7 ]

如何以优雅的方式总结每个N（让我们假设2）个元素并将列表转换为：

[ 1, 5, 9, 13 ]

编辑：我想出了以下解决方案：

    List<Double> input = Arrays.asList(0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0);
    List<Double> output = new ArrayList<>();

    int N = 2;
    IntStream.range(0, (input.size() + N - 1) / N)
            .mapToObj(i -> input.subList(i * N, Math.min(N * (i + 1), input.size())))
            .mapToDouble(l -> l.stream().mapToDouble(Double::doubleValue).sum())
            .forEach(output::add);

    System.out.println(output);

它是有效的，但我仍然在寻找一个更易读、更简单的方法。

Answer 1

下面是另一种方法，使用＜code＞收集器。groupingBy（）：

List<Integer> numbers = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7);
int N = 2;
Collection<Integer> sums =  numbers.stream()
                                   .collect(Collectors.groupingBy(i-> i/N,
                                                                  Collectors.summingInt(Integer::intValue)))
                                   .values();
System.out.println (sums);

输出：

[1, 5, 9, 13]

Answer 2

鉴于：

List<Integer> numbers = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7);
int nth = 2;

怎么样：

IntStream.iterate(0, idx -> idx + nth)
         .limit(numbers.size() / nth)
         .map(idx -> IntStream.range(idx, idx + nth)
                              .reduce((sum, index) -> sum + numbers.get(index))
                              .orElse(0))
         .forEach(System.out::println);

或者替代地：

IntStream.range(0, numbers.size() / nth)
         .map(idx -> IntStream.range(idx * nth, (idx + 1) * nth)
                              .map(index -> numbers.get(index))
                              .sum())
         .forEach(System.out::println);

Answer 3

这是另一种方法，无论您的元素是否排序，它都有效。此外，它不会对您的起始值进行任何预测，并在更广泛的范围内给出正确的结果。即使list.size（）%n==0条件不成立，这种方法仍然有效。因此，从字面上看，它不需要任何先决条件来保持以获得所需的内容。

这种方法背后的直觉是，您的索引是自然排序的，因此可以用来实现我们所需要的。我们可以将元素分组到一个类别中，只要它们当前的索引i / n产生相同的值。然后，使用下游收集器计算属于同一组中的元素的总和。这是它的外观。

Collection<Integer> sumsOfnElements = IntStream.range(0, numbers.size()).boxed()
    .collect(Collectors.groupingBy(i -> i / n, 
        Collectors.summingInt(numbers::get))).values(); 

下面给出了遵循或多或少相同方法的等效迭代解。在性能严格的设置中，我会选择此命令式解决方案，而不是基于流的解决方案。

假设：输入是整数数组，而不是列表。

final float inputLen = input.length;
final int resultLen = (int) Math.ceil(inputLen / n);
final int[] result = new int[resultLen];

for (int i = 0; i < inputLen; i++)
    result[i / n] += input[i];