feat(lambda-expression): mais 2 exemplos e +

Criação de dois novos exemplos. Um com uma interface funcional nossa, para tentar deixar mais claro o conceito. Outro com a utilização de expressão lambda em listas no Java 8, também para tentar deixar mais claro onde se costuma utilizar.

Uma melhoria no último exemplo para não confundir nada relacionado a Thread.

Issue #20

Author: rinaldodev

book/04-lambda/sections/02-lambda-expression.asc

@@ -43,6 +43,47 @@ include::{section-java-package}/lambdaexpression/LambdaExpression_AnonymousClass
 +
 Veja que no exemplo acima é instanciada uma `Thread` com uma instância anônima de `Runnable`. Na segunda parte, é feito a mesma coisa de forma muito mais simples utilizando uma expressão lambda.
 
+. Expressões lambda são sempre utilizadas para criar instâncias de interfaces funcionais, ou seja, interfaces que possuem apenas um único método abstrato.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_FunctionalInterface.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_FunctionalInterface.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+executei com classe anônima
+executei com expressão lambda
+----
++
+Veja que no exemplo acima o mesmo método `executeEApresenteMensagem` é invocado duas vezes. Na primeira vez é passada uma nova classe anônima. Na segunda vez é passado uma expressão lambda.
++
+Veja também que seria impossível criar uma expressão lambda caso a interface não fosse funcional, ou seja, tivesse mais de um método abstrato. Seria impossível para o compilador saber que o que está sendo implementado dentro da expressão lambda é o método `execute` da interface `Executavel`.
+
+. Existem muitos métodos já disponíveis no Java 8 que se beneficiam da sintaxe de expressões lambda, como o `forEach` de listas.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_ForEach.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_ForEach.java[tag=code]
+----
++
+.Saída no console
+[source,console]
+----
+1
+2
+3
+4
+5
+----
++
+Veja que o novo método `forEach` executa a expressão lambda passada como parâmetro para cada item da lista, imprimindo todos no console. Veja também que essa expressão lambda recebe como parâmetro um número, que é o número da lista.
++
+Neste caso, a interface funcional que está sendo implementada pela expressão lambda é chamada `Consumer`. Ela será explicada em detalhes em uma seção posterior, juntamente com outras interfaces funcionais padrões do Java 8. Nesta seção é importante apenas entender o que são as expressões lambda e como é sua sintaxe.
+
 . Declarações de expressões lambda podem ser completas ou simplificadas.
 +
 [source,java,indent=0]
@@ -104,9 +145,9 @@ Perceba que o compilador identifica que a variável `x3` é alterada no final do
 include::{section-java-package}/lambdaexpression/LambdaExpression_TypeInference.java[tag=code]
 ----
 +
-No exemplo anterior, apenas o método `run` da interface funcional `Runnable` retorna uma `String`, enquanto o método `execute` da interface funcional `Executavel` não retorna nada (`void`). Isso é diferença suficiente para o compilador saber qual método chamar cada vez que `rode` é invocado.
+No exemplo anterior, apenas o método `run` da interface funcional `Application` retorna uma `String`, enquanto o método `execute` da interface funcional `Executavel` não retorna nada (`void`). Isso é diferença suficiente para o compilador saber qual método chamar cada vez que `rode` é invocado.
 + 
-Na primeira chamada ao método `rode`, como a expressão lambda passada retorna uma `String`, o compilador entende que essa expressão lambda é uma implementação da interface `Runnable`, pois o método `run` também retorna uma `String`.
+Na primeira chamada ao método `rode`, como a expressão lambda passada retorna uma `String`, o compilador entende que essa expressão lambda é uma implementação da interface `Application`, pois o método `run` também retorna uma `String`.
 +
 Na segunda chamada ao método `rode`, como a expressão lambda não retorna nada (apenas imprime a `String` `"executando"`), o compilador entende que essa expressão lambda é uma implementação da interface `Executavel`, pois o método `execute` também não retorna nada.
 

src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_ForEach.java

@@ -0,0 +1,14 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class LambdaExpression_ForEach {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    List<Integer> lista = Arrays.asList(1, 2, 3, 4, 5);
+    lista.forEach((numero) -> { System.out.println(numero); });
+    // end::code[]
+  }
+}

src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_FunctionalInterface.java

@@ -0,0 +1,30 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+public class LambdaExpression_FunctionalInterface {
+
+  // tag::code[]
+  @FunctionalInterface
+  interface Executavel { // interface funcional
+    String execute(); // método funcional
+  }
+
+  private static void executeEApresenteMensagem(Executavel executavel) {
+    String mensagem = executavel.execute();
+    System.out.println(mensagem);
+  }
+
+  public static void main(String[] args) {
+
+    // com classe anônima
+    executeEApresenteMensagem(new Executavel() {
+      @Override
+      public String execute() {
+        return "executei com classe anônima";
+      }
+    });
+
+    // com expressão lambda
+    executeEApresenteMensagem(() -> { return "executei com expressão lambda"; });
+    // end::code[]
+  }
+}

src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_TypeInference.java

@@ -9,7 +9,7 @@ interface Executavel {
   }
 
   @FunctionalInterface
-  interface Runnable {
+  interface Application {
     String run(); // método funcional também sem argumentos
   }
 
@@ -20,14 +20,14 @@ void rode(Executavel executavel) {
     }
 
     // esse método também pode receber uma expressão lambda sem argumentos
-    void rode(Runnable runnable) {
-      runnable.run();
+    void rode(Application application) {
+      application.run();
     }
   }
 
   public static void main(String[] args) {
     Executor executor = new Executor();
-    executor.rode(() -> { return "executando"; }); // irá chamar o execute que recebe um Runnable
+    executor.rode(() -> { return "executando"; }); // irá chamar o execute que recebe uma Application
     executor.rode(() -> { System.out.println("executando"); }); // irá chamar o execute que recebe um Executavel
   }
   // end::code[]