feat(lambda-expression): regras e exemplos

Regras e exemplos da seção Expressões Lambda.

Issue #20

Author: rinaldodev

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

@@ -10,13 +10,118 @@ Describe a lambda expression; refactor the code that uses an anonymous inner cla
 Descrever uma expressão lambda; refatorar código que usa classes anônimas internas para usar expressões lambda; descrever a inferência de tipos e tipos esperados.
 --------------------------------------------------
 
+Expressões Lambda são parecidos com classes anônimas, porém só possuem a implementação dos métodos. Por isso, são como "métodos anônimos", que podem ser passados via variáveis.
+
+A expressão lambda possui 3 partes:
+
+* Uma lista de parâmetros, separados por vírgula; algumas vezes possui parênteses; algumas vezes possui o tipo das variáveis.
+* O "arrow token", que sempre é escrito como `\->`
+* Um corpo, que pode ou não estar entre chaves; pode possuir mais de uma linha; algumas vezes possui um `return`; algumas vezes possui ponto e vírgula.
+
+Exemplos de expressões lambda:
+
+* `i -> System.out.println(i)`
+* `(Integer i) -> System.out.println(i)`
+* `(Integer i) -> { System.out.println(i); }`
+* `(Integer i) -> { return i + 1; }`
+* `(i, j, k) -> { return i + j + k; }`
+* `(i, j, k) -> System.out.println(i + j + k)`
+* `() -> System.out.println("nada")`
+
+. Expressões lambda podem ser entendidas como uma forma diferente de declarar classes anônimas.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_AnonymousClass.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_AnonymousClass.java[tag=code]
+----
++
+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.
+
+. Declarações de expressões lambda podem ser completas ou simplificadas.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_SimpleComplete.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_SimpleComplete.java[tag=code]
+----
++
+As duas funções lambda acima são idênticas, porém uma é mais explícita do que a outra. 
+
+. Os parênteses só podem ser omitidos caso não haja a declaração do *tipo*, e haja apenas *um único* argumento.
+. Expressões lambda que NÃO possuem argumentos também precisam dos parênteses.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_Parenthesis.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_Parenthesis.java[tag=code]
+----
+
+. Caso a expressão lambda possua mais de uma linha, é obrigatória a utilização de chaves, ponto e vírgula e return (se a função retornar algum valor).
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_Block.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_Block.java[tag=code]
+----
+
+. Ao tornar explícito o tipo de um dos argumentos, é obrigatório informar de todos.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_VarType.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_VarType.java[tag=code]
+----
+
+. Não é permitido declarar variáveis com o mesmo nome dentro da expressão lambda.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_Shadowing.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_Shadowing.java[tag=code]
+----
+
+. É permitido acessar variáveis externas dentro da expressão lambda, mas somente variáveis finais ou variáveis que não são alteradas.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_AccessExternalVar.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_AccessExternalVar.java[tag=code]
+----
++
+Perceba que o compilador identifica que a variável `x3` é alterada no final do método, e por isso não permite que ela seja utilizada na expressão lambda.
+
+. Em situações de ambiguidade, o compilador tenta descobrir o tipo da expressão lambda utilizando o contexto.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_TypeInference.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_TypeInference.java[tag=code]
+----
++
+No exemplo anterior, apenas o método `corra` da interface funcional `Piloto` retorna uma `String`, por isso o compilador sabe que deve chamá-lo.
+
+. Se não for possível descobrir o tipo da expressão lambda, ocorre erro de compilação.
++
+[source,java,indent=0]
+.{java-package}/lambdaexpression/LambdaExpression_Ambiguity.java
+----
+include::{section-java-package}/lambdaexpression/LambdaExpression_Ambiguity.java[tag=code]
+----
++
+No exemplo anterior, como as duas interfaces funcionais possuem métodos com retorno `void`, o compilador não sabe qual das duas está sendo instanciada na expressão lambda, e ocorre erro de compilação. A expressão lambda, nesse exemplo, poderia ser tanto do tipo `Piloto` quanto `Corredor`, e não há como o compilador descobrir qual o desenvolvedor de fato quis utilizar.
+
 .Referências
 ****
 
 * Implementing Functional Interfaces with Lambdas
 +
 Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 55). Wiley. Edição do Kindle. 
 
+* Using Variables in Lambdas
++
+Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 172). Wiley. Edição do Kindle. 
+
 * https://www.baeldung.com/java-8-lambda-expressions-tips[Lambda Expressions and Functional Interfaces: Tips and Best Practices.]
 
 * https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html[Lambda Expressions.] The Java™ Tutorials.

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

@@ -0,0 +1,25 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.function.UnaryOperator;
+
+public class LambdaExpression_AccessExternalVar {
+
+  // tag::code[]
+  public static void main(String[] args) {
+    final Double x1 = 2.0;
+    Double x2 = 2.0;
+    Double x3 = 2.0;
+
+    // COMPILA - variável externa 'x1' é final e pode ser utilizada na expressão lambda
+    UnaryOperator<Double> elevarAoX1 = (Double y) -> Math.pow(y, x1);
+    
+    // COMPILA - variável externa 'x2' não é final, mas nunca é alterada, então pode ser utilizada dentro da expressão lambda
+    UnaryOperator<Double> elevarAoX2 = (Double y) -> Math.pow(y, x2);
+
+    // NÃO COMPILA - variável externa 'x3' é alterada dentro desse método, então não pode ser utilizada dentro da expressão lambda
+    UnaryOperator<Double> elevarAoX3 = (Double y) -> Math.pow(y, x3);
+    
+    x3 = 3.0; // alteração da variável x3 não permite que ela seja utilizada em expressões lambda
+  }
+  // end::code[]
+}

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

@@ -0,0 +1,33 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+public class LambdaExpression_Ambiguity {
+
+  // tag::code[]
+  @FunctionalInterface
+  interface Corredor {
+    void corra();
+  }
+
+  @FunctionalInterface
+  interface Piloto {
+    void corra();
+  }
+
+  static class Executor {
+    void execute(Corredor corredor) {
+      corredor.corra();
+    }
+
+    String execute(Piloto piloto) {
+      piloto.corra();
+      return "correndo";
+    }
+  }
+
+  public static void main(String[] args) {
+    Executor executor = new Executor();
+    // NÃO COMPILA - não é possível determinar o tipo da expressão lambda abaixo
+    executor.execute(() -> System.out.println("execute"));
+  }
+  // end::code[]
+}

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

@@ -0,0 +1,19 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+public class LambdaExpression_AnonymousClass {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    // com classe anônima
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        System.out.println("Executando.");
+      }
+    }).run();
+
+    // com expressão lambda
+    new Thread(() -> System.out.println("Executando.")).run();
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,21 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
+
+public class LambdaExpression_Block {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    UnaryOperator<Double> elevarAoQuadrado = (Double x) -> {
+      double pow = Math.pow(x, 2);
+      return pow;
+    };
+
+    Consumer<Double> imprime = (Double x) -> {
+      double pow = Math.pow(x, 2);
+      System.out.println(pow);
+    };
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,22 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.function.UnaryOperator;
+
+public class LambdaExpression_Parenthesis {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    // NÃO COMPILA - parênteses são obrigatórios ao declarar o tipo da variável da expressão lambda
+    UnaryOperator<Double> elevarAoQuadrado = Double x -> Math.pow(x, 2);
+    
+    // NÃO COMPILA - é obrigatório utilizar parênteses quando há mais de uma variável na expressão lambda
+    BinaryOperator<Double> elevarAoX = y, x -> Math.pow(y, x);
+    
+    // NÃO COMPILA - é obrigatório utilizar parênteses quando não há variáveis
+    Supplier<Double> elevar2aoQuadrado = -> Math.pow(2, 2);
+    
+    // COMPILA - parênteses vazios quando não há variáveis
+    Supplier<Double> elevar2aoQuadrado = () -> Math.pow(2, 2);    
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,22 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.function.BinaryOperator;
+import java.util.function.UnaryOperator;
+
+public class LambdaExpression_Shadowing {
+
+  // tag::code[]
+  public static void main(String[] args) {
+    Double x = 2.0; // variável 'x' no método
+
+    // NÃO COMPILA - a variável com nome 'x' já existe e não pode ser declarada nas variáveis da expressão lambda
+    BinaryOperator<Double> elevarAoX = (Double y, Double x) -> Math.pow(y, x);
+    
+    // NÃO COMPILA - a variável com nome 'x' já existe e não pode ser declarada no corpo da expressão lambda
+    UnaryOperator<Double> elevarAoQuadrado = (Double y) -> {
+      Double x = 2.0;
+      return Math.pow(y, x);
+    };
+  }
+  // end::code[]
+}

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

@@ -0,0 +1,15 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.function.UnaryOperator;
+
+public class LambdaExpression_SimpleComplete {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    // expressão lambda completa
+    UnaryOperator<Double> elevarAoQuadrado1 = (Double x) -> { return Math.pow(x, 2); };
+    // expressão lambda simplificada
+    UnaryOperator<Double> elevarAoQuadrado2 = (x) -> Math.pow(x, 2);
+    // end::code[]
+  }
+}

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

@@ -0,0 +1,31 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+public class LambdaExpression_TypeInference {
+
+  // tag::code[]
+  @FunctionalInterface
+  interface Corredor {
+    void corra();
+  }
+
+  @FunctionalInterface
+  interface Piloto {
+    String corra();
+  }
+
+  static class Executor {
+    void execute(Corredor corredor) {
+      corredor.corra();
+    }
+
+    String execute(Piloto piloto) {
+      return piloto.corra();
+    }
+  }
+
+  public static void main(String[] args) {
+    Executor executor = new Executor();
+    String s = executor.execute(() -> "execute");
+  }
+  // end::code[]
+}

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

@@ -0,0 +1,16 @@
+package org.j6toj8.lambda.lambdaexpression;
+
+import java.util.function.UnaryOperator;
+
+public class LambdaExpression_VarType {
+
+  public static void main(String[] args) {
+    // tag::code[]
+    // NÃO COMPILA - caso o tipo de um dos parâmetros for informado, é necessário informar de todos eles
+    UnaryOperator<Double> elevarAoX = (Double y, x) -> Math.pow(y, x);
+    
+    // COMPILA - todos os parâmetros com tipos informados
+    UnaryOperator<Double> elevarAoX2 = (Double y, Double x) -> Math.pow(y, x);
+    // end::code[]
+  }
+}