blocks|key|151905|text|您尝试使用的两个和三个参数版本的reduce不接受相同类型的accumulator。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|151906|有两个参数reduce是defined+as：|151907|T+reduce(T+identity,
+++++++++BinaryOperator<T>+accumulator)|code-block|syntax|javascript|151908|在本例中，T是字符串，所以BinaryOperator<T>应该接受两个字符串参数并返回一个字符串。但是您将一个int和一个字符串传递给它，这将导致编译错误-+argument+mismatch;+int+cannot+be+converted+to+java.lang.String。实际上，我认为在这里传递0作为标识值也是错误的，因为需要一个字符串(T)。|151909|还要注意，这个版本的reduce处理一个Ts流并返回一个T，因此您不能使用它将字符串流缩减为int。|151910|三个参数reduce为defined+as：|151911|+U+reduce(U+identity,
+++++++++++++BiFunction<U,?+super+T,U>+accumulator,
+++++++++++++BinaryOperator+combiner)|151912|在本例中，U是Integer，T是String，因此此方法会将字符串流减少为Integer。|151913|对于BiFunction<U,?+super+T,U>累加器，您可以传递两种不同类型的参数(U和？super+T)，在您的例子中是Integer和String。此外，在本例中，标识值U接受一个Integer，因此传递它0就可以了。|151914|另一种方法来实现你想要的：|151915|int+length+=+asList("str1",+"str2").stream().mapToInt+(s+->+s.length())
++++++++++++.reduce(0,+(accumulatedInt,+len)+->+accumulatedInt+%2B+len);|151916|在这里，流的类型与reduce的返回类型相匹配，因此您可以使用两个参数版本的reduce。|151917|当然，你根本不需要使用reduce：|151918|int+length+=+asList("str1",+"str2").stream().mapToInt+(s+->+s.length())
++++++++++++.sum();|151919|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-T-java.util.function.BinaryOperator-|1|http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-U-java.util.function.BiFunction-java.util.function.BinaryOperator-^0|G|6|U|B|0|5|6|C|A|0|0|0|D|H|28|1Q|0|0|4|6|B|A|1|0|0|0|2|P|0|0|0|9|6|12|6|0|B|6|0|0^^$0|@$1|2|3|4|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@$9|1Q|A|1R|1|1S]]|E|$]]|$1|H|3|I|5|J|7|1T|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@$9|23|A|24|1|25]]|E|$]]|$1|S|3|T|5|J|7|26|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|27|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|28|8|@$9|29|A|2A|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2B|8|@]|D|@]|E|$]]|$1|10|3|11|5|J|7|2C|8|@]|D|@]|E|$K|L]]|$1|12|3|13|5|6|7|2D|8|@$9|2E|A|2F|B|C]|$9|2G|A|2H|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|2I|8|@$9|2J|A|2K|B|C]]|D|@]|E|$]]|$1|16|3|17|5|J|7|2L|8|@]|D|@]|E|$K|L]]|$1|18|3|-4|5|6|7|2M|8|@]|D|@]|E|$]]]|19|$1A|$5|1B|1C|1D|E|$1E|1F]]|1G|$5|1B|1C|1D|E|$1E|1H]]]]

The two and three argument versions of <code>reduce</code> which you tried to use don't accept the same type for the <code>accumulator</code>.

The two argument <code>reduce</code> is <a href="http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-T-java.util.function.BinaryOperator-">defined as</a> :

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

In your case, T is String, so <code>BinaryOperator&lt;T&gt;</code> should accept two String arguments and return a String. But you pass to it an int and a String, which results in the compilation error you got - <code>argument mismatch; int cannot be converted to java.lang.String</code>. Actually, I think passing 0 as the identity value is also wrong here, since a String is expected (T).

Also note that this version of reduce processes a stream of Ts and returns a T, so you can't use it to reduce a stream of String to an int.

The three argument <code>reduce</code> is <a href="http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-U-java.util.function.BiFunction-java.util.function.BinaryOperator-">defined as</a> :

<pre><code>&lt;U&gt; U reduce(U identity,
 BiFunction&lt;U,? super T,U&gt; accumulator,
 BinaryOperator&lt;U&gt; combiner)
</code></pre>

In your case U is Integer and T is String, so this method will reduce a stream of String to an Integer.

For the <code>BiFunction&lt;U,? super T,U&gt;</code> accumulator you can pass parameters of two different types (U and ? super T), which in your case are Integer and String. In addition, the identity value U accepts an Integer in your case, so passing it 0 is fine.

Another way to achieve what you want :

<pre><code>int length = asList("str1", "str2").stream().mapToInt (s -&gt; s.length())
 .reduce(0, (accumulatedInt, len) -&gt; accumulatedInt + len);
</code></pre>

Here the type of the stream matches the return type of <code>reduce</code>, so you can use the two parameter version of <code>reduce</code>.

Of course you don't have to use <code>reduce</code> at all :

<pre><code>int length = asList("str1", "str2").stream().mapToInt (s -&gt; s.length())
 .sum();
</code></pre>

blocks|key|2738420|text|Eran's+answer描述了reduce的两个参数版本和三个参数版本之间的差异，因为前者将Stream<T>简化为T，而后者将Stream<T>简化为U。然而，它实际上并没有解释为什么在将Stream<T>简化为U时需要额外的组合器功能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2738421|streams+API的设计原则之一是，API不应该在顺序流和并行流之间有所不同，或者换句话说，特定的API不应该阻止流正确地运行，无论是顺序还是并行。如果您的lambda具有正确的属性(关联、非干扰等)顺序或并行运行的流应该会产生相同的结果。|2738422|让我们首先考虑一下reduction的两个参数版本：|2738423|T+reduce(I,+(T,+T)+->+T)|code-block|syntax|javascript|2738424|顺序实现很简单。identity值I与第0个流元素“累加”，以给出结果。该结果与第一流元素累加以给出另一结果，该另一结果又与第二流元素累加，依此类推。最后一个元素累加后，返回最终结果。|2738425|并行实现首先将流分割成多个段。每个段都是由它自己的线程以我上面描述的顺序方式处理的。现在，如果我们有N个线程，我们就有N个中间结果。这些需要减少到一个结果。因为每个中间结果都是T类型的，并且我们有几个，所以我们可以使用相同的累加器函数来将这N个中间结果减少到单个结果。|2738426|现在，让我们考虑一个假设的两参数约简操作，该操作将Stream<T>减少为U。在其他语言中，这称为"fold"或“折叠-左”操作，所以我在这里将其称为“折叠-左”操作。注意，这在Java中是不存在的。|2738427|U+foldLeft(I,+(U,+T)+->+U)|2738428|(请注意，标识值I的类型为U。)|2738429|foldLeft的顺序版本就像reduce的顺序版本一样，只是中间值是U类型而不是T类型，但在其他方面是相同的。(假设的foldRight操作类似，只是操作是从右到左而不是从左到右执行的。)|2738430|现在考虑foldLeft的并行版本。让我们首先将流拆分成多个段。然后，我们可以让N个线程中的每个线程将其段中的T值减少为类型U的N个中间值。现在怎么办？我们如何从U类型的N个值到U类型的单个结果？|2738431|缺少的是另一个函数，将多个类型为U的中间结果组合成一个类型为U的结果。如果我们有一个将两个U值组合为一个的函数，就足以将任意数量的值减少到一个--就像上面的原始缩减一样。因此，给出不同类型结果的归约操作需要两个函数：|BOLD|2738432|U+reduce(I,+(U,+T)+->+U,+(U,+U)+->+U)|2738433|或者，使用Java语法：|2738434|+U+reduce(U+identity,+BiFunction<U,?+super+T,U>+accumulator,+BinaryOperator+combiner)|2738435|总而言之，要对不同的结果类型进行并行缩减，我们需要两个函数:一个是将T元素累加为中间U值，第二个是将中间U值合并为一个单独的U结果。如果我们不切换类型，那么累加器函数与组合器函数是相同的。这就是为什么归约到相同的类型只有累加器函数，而归约到不同的类型需要单独的累加器和组合器函数。|2738436|最后，Java不提供foldLeft和foldRight操作，因为它们暗示了固有的顺序操作的特定顺序。这与上面提到的提供同等支持顺序和并行操作的API的设计原则相冲突。|2738437|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/24308988/1441122|1|https://en.wikipedia.org/wiki/Fold_%2528higher-order_function%2529^0|G|6|1B|9|1N|1|1T|9|25|1|2O|9|30|1|0|D|0|0|0|0|0|H|1|0|0|P|9|11|1|1D|6|1|0|0|8|1|0|0|8|F|6|1O|9|0|4|8|0|A|2Q|0|0|0|C|0|0|0|3W|0|0|2C|A|8|J|9|0^^$0|@$1|2|3|4|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]|$9|20|A|21|B|C]|$9|22|A|23|B|C]]|D|@$9|24|A|25|1|26]]|E|$]]|$1|F|3|G|5|6|7|27|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|28|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|29|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|2A|8|@$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|2D|8|@]|D|@]|E|$]]|$1|S|3|T|5|6|7|2E|8|@$9|2F|A|2G|B|C]|$9|2H|A|2I|B|C]]|D|@$9|2J|A|2K|1|2L]]|E|$]]|$1|U|3|V|5|L|7|2M|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|2N|8|@$9|2O|A|2P|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|2Q|8|@$9|2R|A|2S|B|C]|$9|2T|A|2U|B|C]|$9|2V|A|2W|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|2X|8|@$9|2Y|A|2Z|B|C]]|D|@]|E|$]]|$1|12|3|13|5|6|7|30|8|@$9|31|A|32|B|14]]|D|@]|E|$]]|$1|15|3|16|5|L|7|33|8|@]|D|@]|E|$M|N]]|$1|17|3|18|5|6|7|34|8|@$9|35|A|36|B|14]]|D|@]|E|$]]|$1|19|3|1A|5|L|7|37|8|@]|D|@]|E|$M|N]]|$1|1B|3|1C|5|6|7|38|8|@$9|39|A|3A|B|14]]|D|@]|E|$]]|$1|1D|3|1E|5|6|7|3B|8|@$9|3C|A|3D|B|14]|$9|3E|A|3F|B|C]|$9|3G|A|3H|B|C]]|D|@]|E|$]]|$1|1F|3|-4|5|6|7|3I|8|@]|D|@]|E|$]]]|1G|$1H|$5|1I|1J|1K|E|$1L|1M]]|1N|$5|1I|1J|1K|E|$1L|1O]]]]

<a href="https://stackoverflow.com/a/24308988/1441122">Eran's answer</a> described the differences between the two-arg and three-arg versions of <code>reduce</code> in that the former reduces <code>Stream&lt;T&gt;</code> to <code>T</code> whereas the latter reduces <code>Stream&lt;T&gt;</code> to <code>U</code>. However, it didn't actually explain the need for the additional combiner function when reducing <code>Stream&lt;T&gt;</code> to <code>U</code>.

One of the design principles of the Streams API is that the API shouldn't differ between sequential and parallel streams, or put another way, a particular API shouldn't prevent a stream from running correctly either sequentially or in parallel. If your lambdas have the right properties (associative, non-interfering, etc.) a stream run sequentially or in parallel should give the same results.

Let's first consider the two-arg version of reduction:

<pre><code>T reduce(I, (T, T) -&gt; T)
</code></pre>

The sequential implementation is straightforward. The identity value <code>I</code> is "accumulated" with the zeroth stream element to give a result. This result is accumulated with the first stream element to give another result, which in turn is accumulated with the second stream element, and so forth. After the last element is accumulated, the final result is returned.

The parallel implementation starts off by splitting the stream into segments. Each segment is processed by its own thread in the sequential fashion I described above. Now, if we have N threads, we have N intermediate results. These need to be reduced down to one result. Since each intermediate result is of type T, and we have several, we can use the same accumulator function to reduce those N intermediate results down to a single result.

Now let's consider a hypothetical two-arg reduction operation that reduces <code>Stream&lt;T&gt;</code> to <code>U</code>. In other languages, this is called a <a href="https://en.wikipedia.org/wiki/Fold_%28higher-order_function%29" rel="noreferrer">"fold"</a> or "fold-left" operation so that's what I'll call it here. Note this doesn't exist in Java.

<pre><code>U foldLeft(I, (U, T) -&gt; U)
</code></pre>

(Note that the identity value <code>I</code> is of type U.)

The sequential version of <code>foldLeft</code> is just like the sequential version of <code>reduce</code> except that the intermediate values are of type U instead of type T. But it's otherwise the same. (A hypothetical <code>foldRight</code> operation would be similar except that the operations would be performed right-to-left instead of left-to-right.)

Now consider the parallel version of <code>foldLeft</code>. Let's start off by splitting the stream into segments. We can then have each of the N threads reduce the T values in its segment into N intermediate values of type U. Now what? How do we get from N values of type U down to a single result of type U?

What's missing is another function that combines the multiple intermediate results of type U into a single result of type U. If we have a function that combines two U values into one, that's sufficient to reduce any number of values down to one -- just like the original reduction above. Thus, the reduction operation that gives a result of a different type needs two functions:

<pre><code>U reduce(I, (U, T) -&gt; U, (U, U) -&gt; U)
</code></pre>

Or, using Java syntax:

<pre><code>&lt;U&gt; U reduce(U identity, BiFunction&lt;U,? super T,U&gt; accumulator, BinaryOperator&lt;U&gt; combiner)
</code></pre>

In summary, to do parallel reduction to a different result type, we need two functions: one that accumulates T elements to intermediate U values, and a second that combines the intermediate U values into a single U result. If we aren't switching types, it turns out that the accumulator function is the same as the combiner function. That's why reduction to the same type has only the accumulator function and reduction to a different type requires separate accumulator and combiner functions.

Finally, Java doesn't provide <code>foldLeft</code> and <code>foldRight</code> operations because they imply a particular ordering of operations that is inherently sequential. This clashes with the design principle stated above of providing APIs that support sequential and parallel operation equally.

blocks|key|2738439|text|在没有组合器的情况下，没有接受两个不同类型的reduce版本，因为它不能并行执行(不确定为什么这是一个要求)。累加器必须是关联的这一事实使得这个接口变得非常无用，因为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2738440|list.stream().reduce(identity,
+++++++++++++++++++++accumulator,
+++++++++++++++++++++combiner);|code-block|syntax|javascript|2738441|产生与以下内容相同的结果：|2738442|list.stream().map(i+->+accumulator(identity,+i))
+++++++++++++.reduce(identity,
+++++++++++++++++++++combiner);|2738443|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

There is no reduce version that takes two different types without a combiner since it can't be executed in parallel (not sure why this is a requirement). The fact that accumulator must be associative makes this interface pretty much useless since:

<pre><code>list.stream().reduce(identity,
 accumulator,
 combiner);
</code></pre>

Produces the same results as:

<pre><code>list.stream().map(i -&gt; accumulator(identity, i))
 .reduce(identity,
 combiner);
</code></pre>

blocks|key|2951428|text|因为我喜欢涂鸦和箭头来澄清概念。我们开始吧！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2951429|从字符串到字符串(顺序流)|2951430|假设有4个字符串:您的目标是将这些字符串连接成一个字符串。你基本上是从一个类型开始，然后以相同的类型结束。|2951431|您可以使用以下命令来实现此目的|2951432|String+res+=+Arrays.asList("one",+"two","three","four")
++++++++.stream()
++++++++.reduce("",
++++++++++++++++(accumulatedStr,+str)+->+accumulatedStr+%2B+str);++//accumulator|code-block|syntax|javascript|2951433|这可以帮助你可视化正在发生的事情：|2951434|​|2951435|📷|atomic|offset|length|2951436|2951437|累加器函数一步一步地将(红色)流中的元素转换为最终的减去(绿色)值。累加器函数只是将一个String对象转换为另一个String。|style|CODE|2951438|从字符串到整型(并行流)|2951439|假设有相同的4个字符串:你的新目标是对它们的长度求和，并且你想并行化你的流。|2951440|你需要的是这样的东西：|2951441|int+length+=+Arrays.asList("one",+"two","three","four")
++++++++.parallelStream()
++++++++.reduce(0,
++++++++++++++++(accumulatedInt,+str)+->+accumulatedInt+%2B+str.length(),+++++++++++++++++//accumulator
++++++++++++++++(accumulatedInt,+accumulatedInt2)+->+accumulatedInt+%2B+accumulatedInt2);+//combiner|2951442|这是正在发生的事情的一个计划|2951443|2951444|2951445|2951446|在这里，累加器函数(+BiFunction)允许您将String数据转换为int数据。由于流是平行的，它被分成两个(红色)部分，每个部分都独立于其他部分进行阐述，并产生同样多的部分(橙色)结果。为了提供将部分int结果合并到最终(绿色)+int结果中的规则，需要定义一个组合器。|2951447|从字符串到整型(顺序流)|2951448|如果你不想并行化你的流呢？好吧，无论如何都需要提供一个组合器，但它永远不会被调用，因为不会产生部分结果。|2951449|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/47b28cc12886dc5127ccad28a36c967e.png|imageAlt|1|https://ask.qcloudimg.com/http-save/yehe-900000/90e4a1fc3ab323da56871f4f9f175fe7.png^0|0|0|0|0|0|0|0|0|1|0|0|0|18|6|1M|6|0|0|0|0|0|0|0|0|1|1|0|0|B|A|Q|6|11|3|2W|3|3B|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1X|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|20|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|21|8|@]|9|@$T|22|U|23|1|24]]|A|$]]|$1|V|3|P|5|6|7|25|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|26|8|@$T|27|U|28|Y|Z]|$T|29|U|2A|Y|Z]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2B|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2C|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2D|8|@]|9|@]|A|$]]|$1|16|3|17|5|J|7|2E|8|@]|9|@]|A|$K|L]]|$1|18|3|19|5|6|7|2F|8|@]|9|@]|A|$]]|$1|1A|3|P|5|6|7|2G|8|@]|9|@]|A|$]]|$1|1B|3|R|5|S|7|2H|8|@]|9|@$T|2I|U|2J|1|2K]]|A|$]]|$1|1C|3|P|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2M|8|@$T|2N|U|2O|Y|Z]|$T|2P|U|2Q|Y|Z]|$T|2R|U|2S|Y|Z]|$T|2T|U|2U|Y|Z]|$T|2V|U|2W|Y|Z]]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|2X|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1J|3|-4|5|6|7|2Z|8|@]|9|@]|A|$]]]|1K|$1L|$5|1M|1N|1O|A|$1P|1Q|1R|-4]]|1S|$5|1M|1N|1O|A|$1P|1T|1R|-4]]]]

Since I like doodles and arrows to clarify concepts... let's start!
<h1>From String to String (sequential stream)</h1>
Suppose having 4 strings: your goal is to concatenate such strings into one. You basically start with a type and finish with the same type.
You can achieve this with
<pre><code>String res = Arrays.asList(&quot;one&quot;, &quot;two&quot;,&quot;three&quot;,&quot;four&quot;)
 .stream()
 .reduce(&quot;&quot;,
 (accumulatedStr, str) -&gt; accumulatedStr + str); //accumulator
</code></pre>
and this helps you to visualize what's happening:
<a href="https://i.stack.imgur.com/JNUWm.png" rel="noreferrer"><img src="https://i.stack.imgur.com/JNUWm.png" alt="enter image description here" /></a>
The accumulator function converts, step by step, the elements in your (red) stream to the final reduced (green) value. The accumulator function simply transforms a <code>String</code> object into another <code>String</code>.
<h1>From String to int (parallel stream)</h1>
Suppose having the same 4 strings: your new goal is to sum their lengths, and you want to parallelize your stream.
What you need is something like this:
<pre><code>int length = Arrays.asList(&quot;one&quot;, &quot;two&quot;,&quot;three&quot;,&quot;four&quot;)
 .parallelStream()
 .reduce(0,
 (accumulatedInt, str) -&gt; accumulatedInt + str.length(), //accumulator
 (accumulatedInt, accumulatedInt2) -&gt; accumulatedInt + accumulatedInt2); //combiner
</code></pre>
and this is a scheme of what's happening
<a href="https://i.stack.imgur.com/Sc0lD.png" rel="noreferrer"><img src="https://i.stack.imgur.com/Sc0lD.png" alt="enter image description here" /></a>
Here the accumulator function (a <code>BiFunction</code>) allows you to transform your <code>String</code> data to an <code>int</code> data. Being the stream parallel, it's splitted in two (red) parts, each of which is elaborated independently from eachother and produces just as many partial (orange) results. Defining a combiner is needed to provide a rule for merging partial <code>int</code> results into the final (green) <code>int</code> one.
<h1>From String to int (sequential stream)</h1>
What if you don't want to parallelize your stream? Well, a combiner needs to be provided anyway, but it will never be invoked, given that no partial results will be produced.

I'm having trouble fully understanding the role that the <code>combiner</code> fulfills in Streams <code>reduce</code> method.
For example, the following code doesn't compile:
<pre><code>int length = asList(&quot;str1&quot;, &quot;str2&quot;).stream()
 .reduce(0, (accumulatedInt, str) -&gt; accumulatedInt + str.length());
</code></pre>
Compile error says :
(argument mismatch; int cannot be converted to java.lang.String)
but this code does compile:
<pre><code>int length = asList(&quot;str1&quot;, &quot;str2&quot;).stream() 
 .reduce(0, (accumulatedInt, str ) -&gt; accumulatedInt + str.length(), 
 (accumulatedInt, accumulatedInt2) -&gt; accumulatedInt + accumulatedInt2);
</code></pre>
I understand that the combiner method is used in parallel streams - so in my example it is adding together two intermediate accumulated ints.
But I don't understand why the first example doesn't compile without the combiner or how the combiner is solving the conversion of string to int since it is just adding together two ints.
Can anyone shed light on this?

Why is a combiner needed for reduce method that converts type in java 8

数据转换

Java

我很难完全理解combiner在Streams reduce方法中所扮演的角色。例如，以下代码无法编译：int length = asList("str1", "str2").stream()            .reduce(0, (accumulatedInt, str) -> accumulatedInt +...

问为什么在java 8中转换类型的reduce方法需要一个组合器？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在java 8中转换类型的reduce方法需要一个组合器？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在java 8中转换类型的reduce方法需要一个组合器？
EN