Java - 使用 forEach 或 Stream API 执行累积总和

Question

这里我当前的代码对哈希表执行累积求和 Map<字符串，双精度>

START.forEach((k,v)->{
sum += v;
END.put(k, sum);
});

或者，或者，

END= START.entrySet()
.stream()
.collect(
Collectors.toMap(entry -> entry.getKey(), 
entry -> {
sum += entry.getValue();
return sum;
}));

但是我有以下错误：

Local variable sum defined in an enclosing scope must be final or effectively final

我该如何解决它？

我不想像这样使用标准的循环：

Iterator it = START.entrySet().iterator();
double sum = 0;
while (it.hasNext()) {
Map.Entry pair = (Map.Entry)it.next();
String key = (String) pair.getKey();
Double value = (Double) pair.getValue();
sum+=value;
END.put(date, sum);
}

START
------------
|first | 1 |
|second| 5 |
|third | 4 |
END
|first | 1  | 
|second| 6  |
|third | 10 |

Answer 1

条目的顺序对于累积总和很重要。如果您使用HashMap作为实现，则它不保证映射的顺序;特别是，它不保证订单会随着时间的推移保持不变。所以我建议你使用另一种实现，比如LinkedHashMap。它使用 Map 接口的哈希表和链表实现，具有可预测的迭代顺序。

Map<String, Double> map = new LinkedHashMap<>();
map.put("first", 1.0);
map.put("second", 5.0);
map.put("third", 4.0);

使用原子引用来避免"最终"问题。在 Java 中，您不能在 lambda 以及匿名内部类中使用非最终变量。这就是为什么您收到消息"封闭作用域中定义的局部变量总和必须是最终的或有效的最终的"。然后，您可以将二元运算符定义为(x, y) -> x + y，因为您希望用以前的累积总和汇总当前条目的值。

AtomicReference<Double> atomicSum = new AtomicReference<>(0.0);
map.entrySet().forEach(e -> e.setValue(
atomicSum.accumulateAndGet(e.getValue(), (x, y) -> x + y)
));

---

这是最终代码。

Map<String, Double> map = new LinkedHashMap<>();
map.put("first", 1.0);
map.put("second", 5.0);
map.put("third", 4.0);
AtomicReference<Double> atomicSum = new AtomicReference<>(0.0);
map.entrySet().forEach(e -> e.setValue(
atomicSum.accumulateAndGet(e.getValue(), (x, y) -> x + y)
));
// tested in JUnit
assertEquals(10.0, atomicSum.get(), 0.0001);
assertEquals(1.0, map.get("first"), 0.0001);
assertEquals(6.0, map.get("second"), 0.0001);
assertEquals(10.0, map.get("third"), 0.0001);

Answer 2

你需要sum成为AtomicLong并执行addAndGet而不是+=，因为正如错误所说，你需要总和是最终的。

Answer 3

我不知道，但这段代码可能会对您有所帮助。

List<Integer> ints = new ArrayList<>();
ints.add(1);
ints.add(2);
ints.add(3);
AtomicInteger sum = new AtomicInteger(0);
ints.stream().sequential().mapToInt(sum::addAndGet).forEach(System.out::println);

尝试在代码中修改并使用此代码段。

Answer 4

您可以使用如下所示的java.util.concurrent.DoubleAdder和Collectors#toMap：

final Map<String, Double> START = new HashMap<>();
START.put("first", 1.0);
START.put("second", 5.0);
START.put("third", 4.0);
System.out.println(START.toString());
DoubleAdder sum = new DoubleAdder();
Map<String, Double> cumulativeSum = START.entrySet().stream().sequential().collect(
Collectors.toMap(Entry::getKey, it -> { sum.add(it.getValue()); return sum.sum(); }));
System.out.println(cumulativeSum.toString());