feat(using-streams): operações finais

Adicionando os exemplos de Operações Finais em Streams.

Ref. Issue #23

Author: rinaldodev

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

@@ -263,10 +263,81 @@ Perceba que nesse caso existem 3 `Arrays` distintos. Então cria-se um _Stream_
 
 ===== Operações finais
 
-. forEach que já estava sendo utilizado
-. max, min, count
-. findAny, findFirst
-. allMatch, anyMatch, noneMatch
+. É possível executar uma ação final para cada elemento do _Stream_ utilizando a operação ``forEach``, conforme demonstrado nos exemplos anteriores.
+
+. É possível recuperar o maior e o menor valor de um _Stream_ utilizando as operações finais `max` e ``min``.
+. É possível recuperar a quantidade de elementos de um _Stream_ utilizando a operação final ``count``.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_MaxMinCount.java
+----
+include::{section-java-package}/usingstreams/Streams_MaxMinCount.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+Max: 9
+Min: 1
+Count: 8
+----
++
+No caso das operações `max` e `min`, é necessário passar como argumento qual comparador será utilizado. Como os números possuem uma ordem natural, isto é, implementam a interface ``Comparable``, é possível utilizar um comparador que usa essa ordem natural, que é o ``Comparator.naturalOrder()``. Caso seja um tipo de objeto que não possui uma ordem natural, é necessário passar como argumento uma outra implementação de ``Comparator``.
+
+. É possível pegar o primeiro elemento do Stream utilizando a operação final ``findFirst``, ou um elemento qualquer com ``findAny``.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_FindFirstAny.java
+----
+include::{section-java-package}/usingstreams/Streams_FindFirstAny.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+First: 7
+Any: 7
+----
++
+Nesse caso, como o _Stream_ é sequencial e não paralelo, os dois resultados são iguais. Em _Streams_ paralelos, que serão apresentados em uma próxima seção, a operação `findAny` pode trazer resultados diferentes.
+
+. É possível verificar se os elementos do _Stream_ atendem a alguma validação utilizando as operações finais ``allMatch``, ``anyMatch`` e `noneMatch`.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_Match.java
+----
+include::{section-java-package}/usingstreams/Streams_Match.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+anyMatch: true
+allMatch: false
+noneMatch: false
+----
++
+Perceba que na primeira operação é verificado se *qualquer* elemento é maior do que 5. Na segunda, se *todos* os elementos são maiores do que 5. E na terceira, se *nenhum* elemento é maior do que 5.
+
+. Não é possível chamar mais de uma operação final no mesmo __Stream__.
++
+[source,java,indent=0]
+.{java-package}/usingstreams/Streams_ReuseStream.java
+----
+include::{section-java-package}/usingstreams/Streams_ReuseStream.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+7
+2
+1
+Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
+	at java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
+	at java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:580)
+	at org.j6toj8.streams.usingstreams.Streams_ReuseStream.main(Streams_ReuseStream.java:11)
+----
 
 ===== Pipeline
 

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

@@ -0,0 +1,19 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class Streams_FindFirstAny {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    Optional<Integer> findFirst = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .findFirst(); // pega o primeiro número do Stream
+    System.out.println("First: " + findFirst.get());
+
+    Optional<Integer> findAny = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .findAny(); // pega qualquer número do Stream
+    System.out.println("Any: " + findAny.get());
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,23 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.stream.Stream;
+
+public class Streams_Match {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    boolean anyMatch = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .anyMatch(e -> e > 5); // vefifica se algum elemento é maior que 5
+    System.out.println("anyMatch: " + anyMatch);
+
+    boolean allMatch = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .allMatch(e -> e > 5); // vefifica se TODOS os elementos são maior que 5
+    System.out.println("allMatch: " + allMatch);
+    
+    boolean noneMatch = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .noneMatch(e -> e > 5); // vefifica NENHUM elemento é maior que 5
+    System.out.println("noneMatch: " + noneMatch);
+
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,24 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.Comparator;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class Streams_MaxMinCount {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    Optional<Integer> max = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .max(Comparator.naturalOrder()); // pega o maior número do Stream
+    System.out.println("Max: " + max.get());
+
+    Optional<Integer> min = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .min(Comparator.naturalOrder()); // pega o menor número do Stream
+    System.out.println("Min: " + min.get());
+
+    long count = Stream.of(7, 2, 1, 8, 4, 9, 2, 8) // stream de vários Integer
+        .count(); // pega a quantidade de elementos do Stream
+    System.out.println("Count: " + count);
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,14 @@
+package org.j6toj8.streams.usingstreams;
+
+import java.util.stream.Stream;
+
+public class Streams_ReuseStream {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    Stream<Integer> stream = Stream.of(7, 2, 1);
+    stream.forEach(System.out::println); // imprime elementos do Stream
+    stream.forEach(System.out::println); // LANÇA EXCEÇÃO - o Stream já estava fechado
+    // end::code[]
+  }
+}