blocks|key|115685|text|不是的。累加器不应该修改它的参数；它接受两个值并产生一个新值。如果您想在累积过程中使用突变(例如，将字符串累积到StringBuffer中而不是连接)，请使用Stream.collect()，它就是为此而设计的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|115686|这里有一个代码示例，如果你尝试这样做，它会产生错误的答案。假设你想用一个假设的MutableInteger类做加法：|115687|//+Don't+do+this
MutableInteger+result+=+stream.reduce(new+MutableInteger(0),+(a,b)+->+a.add(b.get()));|code-block|syntax|javascript|115688|这得到错误答案的原因之一是，如果我们并行拆分计算，现在两个计算共享相同的可变起始值。请注意：|115689|a+%2B+b+%2B+c+%2B+d
=+0+%2B+a+%2B+b+%2B+0+%2B+c+%2B+d++//+0+denotes+identity
=+(0+%2B+a+%2B+b)+%2B+(0+%2B+c+%2B+d)+//+associativity|115690|因此，我们可以自由地拆分流，计算部分和0+%2B+a+%2B+b和0+%2B+c+%2B+d，然后将结果相加。但如果它们共享相同的标识值，并且该值因其中一次计算而发生变化，则另一次计算可能以错误的值开始。|115691|(请进一步注意，如果实现认为这是值得的，即使是顺序计算，也可以这样做。)|115692|entityMap^0|27|G|0|0|0|0|0|J|9|T|9|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|18|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|V|$]]

No. The accumulator should not modify its arguments; it takes two values and produces a new value. If you want to use mutation in the course of accumulation (e.g., accumulating strings into a StringBuffer instead of concatenating), use <code>Stream.collect()</code>, which is designed for this.

Here's an example of code that produces the wrong answer if you try this. Let's say you want to do addition with a hypothetical MutableInteger class: 

<pre><code>// Don't do this
MutableInteger result = stream.reduce(new MutableInteger(0), (a,b) -&gt; a.add(b.get()));
</code></pre>

One reason this gets the wrong answer is that if we break the computation up in parallel, now two computations are sharing the same mutable starting value. Note that:

<pre><code>a + b + c + d
= 0 + a + b + 0 + c + d // 0 denotes identity
= (0 + a + b) + (0 + c + d) // associativity
</code></pre>

so we are free to split the stream, compute the partial sums <code>0 + a + b</code> and <code>0 + c + d</code>, and then add the results. But if they are sharing the same identity value, and that value is mutated as a result of one of the computations, the other may start with the wrong value. 

(Note further that the implementation would be allowed to do this even for sequential computations, if it thought that was worthwhile.)

blocks|key|115747|text|这在语法上是允许的，但我认为这与设计模式背道而驰，是一个坏主意。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|115748|++static+void+accumulatorTest()+{
+++++ArrayList<Point>+points+=+new+ArrayList<>();
+++++points.add(new+Point(5,+6));
+++++points.add(new+Point(0,+6));
+++++points.add(new+Point(1,+9));
+++++points.add(new+Point(4,+16));
+++++BinaryOperator<Point>+sumPoints+=+new+BinaryOperator<Point>()+{
++++++++public+Point+apply(Point+p1,+Point+p2)+{
+++++++++++p2.x+%2B=+p1.x;
+++++++++++p2.y+%2B=+p1.y;
+++++++++++return+new+Point(p2);+//return+p2+and+the+list+is+transformed+into+running+total
++++++++}
+++++};
+++++Point+sum+=+points.stream().reduce(new+Point(0,+0),+sumPoints);+
+++++System.out.println(sum);
+++++System.out.println(points);
++}|code-block|syntax|javascript|115749|答案是正确的；我们得到了所有x和y坐标的和。修改原始列表，并通过输出确认：|115750|java.awt.Pointx=10、y=37java.awt.Pointx=5、y=6、java.awt.Pointx=5、y=12、java.awt.Pointx=6、y=21、java.awt.Pointx=10、y=37]|115751|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is allowed syntactically, but I think it runs against the design pattern and is a bad idea.

<pre><code> static void accumulatorTest() {
 ArrayList&lt;Point&gt; points = new ArrayList&lt;&gt;();
 points.add(new Point(5, 6));
 points.add(new Point(0, 6));
 points.add(new Point(1, 9));
 points.add(new Point(4, 16));
 BinaryOperator&lt;Point&gt; sumPoints = new BinaryOperator&lt;Point&gt;() {
 public Point apply(Point p1, Point p2) {
 p2.x += p1.x;
 p2.y += p1.y;
 return new Point(p2); //return p2 and the list is transformed into running total
 }
 };
 Point sum = points.stream().reduce(new Point(0, 0), sumPoints); 
 System.out.println(sum);
 System.out.println(points);
 }
</code></pre>

The answer is correct; we get the sum of all of the x and y coordinates. The original list is modified, confirmed by the output:

java.awt.Point[x=10,y=37]
[java.awt.Point[x=5,y=6], java.awt.Point[x=5,y=12], java.awt.Point[x=6,y=21], java.awt.Point[x=10,y=37]]

In Java 8, Stream has a method reduce:

<pre><code>T reduce(T identity, BinaryOperator&lt;T&gt; accumulator);
</code></pre>

Is the accumulator operator allowed to modify either of its arguments? I presume not since the JavaDoc says the accumulator should be NonInterfering, though all examples talk of modifying the collection, rather than modifying the elements of the collection.

So, for a concrete example, if we have

<pre><code> integers.reduce(0, Integer::sum);
</code></pre>

and suppose for a moment that <code>Integer</code> was mutable, would <code>sum</code> be allowed to modify its first parameter by adding to it (in place) the value of its second parameter?

I presume not, but I would also like an example of where this Interfering causes a problem.

Is the accumulator of reduce in Java 8 allowed to modify its arguments?

Java

在Java 8中，Stream有一个方法reduce：T reduce(T identity, BinaryOperator<T> accumulator);是否允许累加器运算符修改其任何一个参数？我假设没有，因为JavaDoc说累加器应该是NonInterfering，尽管所有的例子都在讨论修改集合，而不是修改集合的...

问Java 8中的reduce累加器允许修改它的参数吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java 8中的reduce累加器允许修改它的参数吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java 8中的reduce累加器允许修改它的参数吗？
EN