feat(using-streams): pipeline e lazy

Adicionando explicação e exemplos de Pipeline de Stream, e as explicações sobre a execução sob-demanda de operações (lazy).

Ref. Issue #23

Author: rinaldodev

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

@@ -341,15 +341,93 @@ Exception in thread "main" java.lang.IllegalStateException: stream has already b
 
 ===== Pipeline
 
-. Exemplos com várias operações
-. Mudar a lista depois de criar o Stream
-. Encadeamento de chamada com Optional
+. É possível criar um _pipeline_ com várias operações em um único __Stream__.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_Pipeline.java
+----
+include::{section-java-package}/usingstreams/Streams_Pipeline.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+8
+12
+----
++
+Para entender todas as operações realizadas nesse pipeline, é necessário entender passo a passo:
++
+.. Foi criado um _Stream_ contendo todos os números de 0 a 9
+.. Foi aplicado um filtro mantendo apenas os números pares: 0, 2, 4, 6 e 8
+.. Foram ignorados os dois primeiros números, mantendo apenas: 4, 6 e 8
+.. Foi limitado o processamento aos dois primeiros números: 4 e 6
+.. Foi aplicada uma multiplicação por 2 em cada elemento, resultando em: 8 e 12
+.. Os dois elementos foram impressos no console.
+
+. O Stream só será criado de fato depois que alguma operação for executada nele.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_ChangeBackingList.java
+----
+include::{section-java-package}/usingstreams/Streams_ChangeBackingList.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+1
+2
+3
+4
+----
++
+Perceba que, mesmo que o _Stream_ aparentemente tenha sido criado antes de adicionar o número 4 na lista, ele imprime esse número no console. Isso acontece porque o _Stream_ só foi criado de fato quando alguma operação foi feita nele, ou seja, quando o `forEach` foi invocado.
+
+. É possível encadear a operação final do _Stream_ utilizando expressões lambda na classe ``Optional``.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_Optional.java
+----
+include::{section-java-package}/usingstreams/Streams_Optional.java[tag=code]
+----
++
+Perceba que o método `ifPresent` é da classe `Optional`, mesmo que no segundo exemplo possa parecer que ele faz parte do __Stream__. Em outras palavras, a operação final é `max`, e `ifPresent` é uma chamada em `Optional` e não mais no __Stream__.
 
 ===== Execução sob-demanda (__lazy__)
 
-<Explicação>
+As operações intermediárias de um _Stream_ só são executadas quando necessário. Ou seja, mesmo que a operação esteja presente no __pipeline__, não é certeza de que ela será executada.
+
+. Nada será feito se o _Stream_ não contiver uma operação final.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_LazyNoFinal.java
+----
+include::{section-java-package}/usingstreams/Streams_LazyNoFinal.java[tag=code]
+----
++
+Nesse caso nada é impresso no console, pois *nenhuma* operação *final* foi aplicada no __Stream__. Ou seja, se não há nada consumindo o resultado desse __Stream__, o Java nem precisa executar o _pipeline_ criado.
 
-. Exemplos de lazy
+. Outras operações intermediárias também não costumam ser executadas se não for necessário.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_LazyMap.java
+----
+include::{section-java-package}/usingstreams/Streams_LazyMap.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Peek: 0
+ForEach: 0
+Peek: 1
+ForEach: 1
+Peek: 2
+ForEach: 2
+----
++
+Perceba que, mesmo que a operação `peek` esteja antes da operação `limit`, ela não é executada para todos os elementos do ``Stream``, apenas para aqueles que serão realmente utilizados.
 
 .Referências
 ****

src/org/j6toj8/streams/usingstreams/Streams_ChangeBackingList.java

@@ -0,0 +1,22 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.ArrayList;
+import java.util.stream.Stream;
+
+public class Streams_ChangeBackingList {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    ArrayList<Integer> list = new ArrayList<Integer>();
+    list.add(1);
+    list.add(2);
+    list.add(3);
+
+    Stream<Integer> stream = list.stream();
+    
+    list.add(4);
+    
+    stream.forEach(System.out::println);
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/usingstreams/Streams_LazyMap.java

@@ -0,0 +1,15 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.stream.IntStream;
+
+public class Streams_LazyMap {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    IntStream.range(0, 10)
+      .peek(e -> System.out.println("Peek: " + e))
+      .limit(3)
+      .forEach(e -> System.out.println("ForEach: " + e)); 
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/usingstreams/Streams_LazyNoFinal.java

@@ -0,0 +1,16 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.stream.IntStream;
+
+public class Streams_LazyNoFinal {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    IntStream.range(0, 4)
+      .filter(e -> e % 2 == 0)
+      .limit(3)
+      .map(e -> e * 2)
+      .peek(System.out::println); 
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/usingstreams/Streams_Optional.java

@@ -0,0 +1,23 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class Streams_Optional {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    // Exemplo sem encadear a chamada de Optional
+    Optional<Integer> max = Stream.of(7, 2, 1)
+        .max(Comparator.naturalOrder());
+    
+    max.ifPresent(System.out::println);
+    
+    // Exemplo encadeando a chamada de Optional
+    Stream.of(7, 2, 1)
+        .max(Comparator.naturalOrder())
+        .ifPresent(System.out::println);
+    // end::code[]
+  }
+}

src/org/j6toj8/streams/usingstreams/Streams_Pipeline.java

@@ -0,0 +1,17 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.stream.IntStream;
+
+public class Streams_Pipeline {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    IntStream.range(0, 10) // Stream de 0 a 9
+        .filter(e -> e % 2 == 0) // mantém apenas números pares
+        .skip(2) // ignora os dois primeiros
+        .limit(2) // limita a 3 elementos
+        .map(e -> e * 2) // multipla cada elemento por 2
+        .forEach(System.out::println); // imprime cada elemento
+    // end::code[]
+  }
+}