feature(using-streams): exemplos de reduce

Adicionando exemplos de reduce.

Ref. Issue #23

Author: rinaldodev

book/05-java-streams/sections/01-using-streams.asc

@@ -533,14 +533,70 @@ Soma: 45
 Média: 4.5
 ----
 
-==== Collectors
+==== _Reduce_ e _Collectors_
+
+===== Reduce
+
+_Reduce_ é uma das principais operações final que podem ser feitas em um _Stream_. _Reduce_ é uma operação que transforma os vários valores do _Stream_ em um único valor. Várias operações apresentadas anteriormente são um tipo de _Reduce_, como: `max`, `min` e `summaryStatistics`. Porém, nem sempre essas operações são suficientes, e por isso existem os métodos `reduce`. Eles permitem a implementação de operações personalizadas de _Reduce_.
+
+. É possível criar uma operação de Reduce personalizada com o método `reduce()` que recebe 1 argumento.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/primitives/Streams_Reduce.java
+----
+include::{section-java-package}/usingstreams/primitives/Streams_Reduce.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+336
+----
++
+Nesse caso está sendo feito um _Reduce_ onde o resultado da operação anterior é passado para a próxima execução. Ou seja, primeiro é feita a multiplicação de 7 * 2, que é 14. Então a função é chamada novamente passando como argumento o resultado anterior (14) e o próximo número do Stream (3). O resultado é 42. Então a função é chamada uma última vez passando o resultado anterior (42) e o próximo número do Stream (8), o que dá o resultado de 336.
+
+. É possível criar uma operação de _Reduce_ informando o valor de identidade.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/primitives/Streams_ReduceIdentity.java
+----
+include::{section-java-package}/usingstreams/primitives/Streams_ReduceIdentity.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+336
+----
++
+Nesse caso é possível informar o valor de identidade da função. O conceito de valor ou função de identidade são um pouco mais complexos, mas para a certificação apenas compreenda que ele representa um valor neutro. Ou seja, para a operação de multiplicação, o valor de identidade é 1, pois qualquer valor multiplicado por 1 resulta nele mesmo. Caso fosse uma operação de soma, o valor de identidade seria 0, pois qualquer valor somado a 0 resulta nele mesmo. 
++
+Além disso, se o _Stream_ estiver vazio, o valor de identidade será retornado. Por isso, diferente do exemplo anterior, não é necessário retornar um `Optional`.
+
+. É possível criar uma operação de _Reduce_ que pode ser executada em várias _Threads_ e depois combinada em um único valor.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/primitives/Streams_ReduceCombiner.java
+----
+include::{section-java-package}/usingstreams/primitives/Streams_ReduceCombiner.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+336
+----
++
+Nesse caso é passado um argumento adicional. Ele é a função de combinação. Essa função é utilizada quando o _Stream_ é paralelo, ou seja, utiliza mais de uma _thread_. Ela pega o valor retornado por 2 ou mais _threads_ e combina-os em um único valor. Em uma operação de multiplicação, a combinação também é uma multiplicação. Ou seja, caso a primeira _thread_ multiplique 7 e 2, resultando em 14, e a segunda multiplique 3 e 8, resultando em 24, a função de combinação só precisa multiplicar 14 por 24 para chegar ao valor de 336. Sendo assim, a função de combinação só faz sentido em um _Stream_ paralelo, que será apresentado no próximo capítulo.
+
+===== Collect
 
 . collect
 . joining
 . averaging int
 . toCollection
 . toMap
-. toMap com construtor do mapa (3 param)
+. toMap (3 param)
 . groupingBy
 . groupingBy (2 param)
 . groupingBy (3 param)

src/org/j6toj8/streams/usingstreams/reduce/Streams_Reduce.java

@@ -0,0 +1,16 @@
+package org.j6toj8.streams.usingstreams.reduce;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class Streams_Reduce {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    Optional<Integer> reduce = Stream.of(7, 2, 3, 8)
+      .reduce((e1, e2) ->  e1 * e2); // reduce que multiplica todos os números
+    
+    System.out.println(reduce.get());
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/usingstreams/reduce/Streams_ReduceCombiner.java

@@ -0,0 +1,15 @@
+package org.j6toj8.streams.usingstreams.reduce;
+
+import java.util.stream.Stream;
+
+public class Streams_ReduceCombiner {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    Integer reduce = Stream.of(7, 2, 3, 8)
+      .reduce(1, (e1, e2) ->  e1 * e2, (e1, e2) ->  e1 * e2);
+    
+    System.out.println(reduce);
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/usingstreams/reduce/Streams_ReduceIdentity.java

@@ -0,0 +1,15 @@
+package org.j6toj8.streams.usingstreams.reduce;
+
+import java.util.stream.Stream;
+
+public class Streams_ReduceIdentity {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    Integer reduce = Stream.of(7, 2, 3, 8)
+      .reduce(1, (e1, e2) ->  e1 * e2);
+    
+    System.out.println(reduce);
+    // end::code[]
+  }
+}