diff --git a/book/04-lambda/sections/02-lambda-expression.asc b/book/04-lambda/sections/02-lambda-expression.asc index 973019a..e0d24b2 100644 --- a/book/04-lambda/sections/02-lambda-expression.asc +++ b/book/04-lambda/sections/02-lambda-expression.asc @@ -2,31 +2,29 @@ :section-java-package: ../../../{java-package} [[lambda-expression]] -=== Expressões Lambda (Lambda Expression) +=== Lambda Expression -.Objetivo +.Objective -------------------------------------------------- Describe a lambda expression; refactor the code that uses an anonymous inner class to use a lambda expression; describe type inference and target typing. -- -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 parecidas 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. +Lambda expressions are similar to anonymous classes, but only have the implementation of the methods. Therefore, they are like "anonymous methods" that can be passed via variables. -É essencial o entendimento de funções lambda, e das variações em sua sintaxe, para compreender as próximas seções de Interfaces Funcionais Pré-Construídas e de Referências a métodos. +Understanding lambda functions, and variations in their syntax, is essential to understanding the next sections of Built-in Interfaces and Method References. -A expressão lambda possui 3 partes: +The lambda expression has 3 parts: -. 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 +. A comma-separated list of parameters +* Sometimes has parentheses +* Sometimes has variable type +. The "arrow token", which is always written as `\->` +. A body, which may or may not be enclosed in braces +* Can have more than one line +* Sometimes has a `return` +* Sometimes has semicolon -Exemplos de expressões lambda: +Examples of lambda expressions: * `i -> System.out.println(i)` * `(Integer i) -> System.out.println(i)` @@ -34,11 +32,11 @@ Exemplos de expressões lambda: * `(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")` +* `() -> System.out.println("nothing")` //- -. Expressões lambda podem ser entendidas como uma forma diferente de declarar classes anônimas. +. Lambda expressions can be understood as a different way of declaring anonymous classes. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_AnonymousClass.java @@ -46,9 +44,9 @@ Exemplos de expressões lambda: 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. +Note that in the example above a `Thread` is instantiated with an anonymous instance of `Runnable`. In the second part, the same thing is done much simpler using a lambda expression. -. 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. +. Lambda expressions are always used to create instances of functional interfaces, i.e., interfaces that have only a single abstract method. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_FunctionalInterface.java @@ -56,18 +54,18 @@ Veja que no exemplo acima é instanciada uma `Thread` com uma instância anônim include::{section-java-package}/lambdaexpression/LambdaExpression_FunctionalInterface.java[tag=code] ---- + -.Saída no console +.console output [source,console] ---- -executei com classe anônima -executei com expressão lambda +performed with anonymous class +performed with lambda expression ---- + -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. +Note that in the example above the same `executeAndPresentMessage` method is invoked twice. The first time a new anonymous class is passed. The second time a lambda expression is passed. + -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. O compilador não saberia identificar que o método `execute`, da interface `Executavel`, está sendo implementado dentro da expressão lambda. +Also see that it would be impossible to create a lambda expression if the interface was not functional, i.e., it had more than one abstract method. The compiler would not be able to identify that the `execute` method of the` Executable` interface is being implemented within the lambda expression. -. Existem muitos métodos já disponíveis no Java 8 que se beneficiam da sintaxe de expressões lambda, como o `forEach` de listas. +. There are many methods already available in Java 8 that benefit from lambda expression syntax, such as `forEach` lists. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_ForEach.java @@ -75,7 +73,7 @@ Veja também que seria impossível criar uma expressão lambda caso a interface include::{section-java-package}/lambdaexpression/LambdaExpression_ForEach.java[tag=code] ---- + -.Saída no console +.console output [source,console] ---- 1 @@ -85,11 +83,11 @@ include::{section-java-package}/lambdaexpression/LambdaExpression_ForEach.java[t 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. A expressão lambda recebe como parâmetro um número, que é o número da lista. +Note that the new `forEach` method executes the lambda expression passed as a parameter to each list item, printing them all to the console. The lambda expression takes as a parameter a number, which is the list number. + -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. +In this case, the functional interface being implemented by the lambda expression is called `Consumer`. It will be explained in detail in a later section, along with other standard Java 8 functional interfaces. In this section, it is essential to understand what lambda expressions are and what their syntax is like. -. Declarações de expressões lambda podem ser completas ou simplificadas. +. Declarations of lambda expressions can be complete or simplified. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_SimpleComplete.java @@ -97,10 +95,10 @@ Neste caso, a interface funcional que está sendo implementada pela expressão l 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. +The two lambda functions above are identical, but one is more explicit than the other. -. 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. +. Parentheses can only be omitted if there is no *type* declaration, and there is only *a single* argument. +. Lambda expressions that do NOT have arguments also need parentheses. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_Parenthesis.java @@ -108,7 +106,7 @@ As duas funções lambda acima são idênticas, porém uma é mais explícita do include::{section-java-package}/lambdaexpression/LambdaExpression_Parenthesis.java[tag=code] ---- -. É obrigatória a utilização de chaves, ponto e vírgula e `return` (caso a função retorne algum valor) em expressões lambda com mais de uma linha. +. The use of curly brackets, semicolons and `return` (if the function returns any value) is required in lambda expressions with more than one line. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_Block.java @@ -116,7 +114,7 @@ include::{section-java-package}/lambdaexpression/LambdaExpression_Parenthesis.ja 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. +. When making the type of one of the arguments explicit, it is mandatory to inform all of them. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_VarType.java @@ -124,7 +122,7 @@ include::{section-java-package}/lambdaexpression/LambdaExpression_Block.java[tag 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. +. It is not allowed to declare variables with the same name within the lambda expression. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_Shadowing.java @@ -132,7 +130,7 @@ include::{section-java-package}/lambdaexpression/LambdaExpression_VarType.java[t 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. +. It is allowed to access external variables within the lambda expression, but only final variables or variables that do not change. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_AccessExternalVar.java @@ -140,9 +138,9 @@ include::{section-java-package}/lambdaexpression/LambdaExpression_Shadowing.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. +Note that the compiler identifies that the `x3` variable is changed at the end of the method, and therefore does not allow it to be used in the lambda expression. -. Em situações de ambiguidade, o compilador tenta descobrir o tipo da expressão lambda utilizando o contexto. +. In ambiguous situations, the compiler tries to find out the type of lambda expression using the context. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_TypeInference.java @@ -150,13 +148,13 @@ 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 `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 `Application`, pois o método `run` também retorna uma `String`. +In the previous example, only the `run` method of the `Application` functional interface returns a `String`, while the `execute` method of the `Executable` functional interface returns nothing (`void`). This is enough difference for the compiler to know which method to call each time `doThis` is invoked. + -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. +On the first call to the `doThis` method, since the passed lambda expression returns a `String`, the compiler understands that this lambda expression is an implementation of the `Application` interface, as the `run` method also returns a `String`. ++ +On the second call to the `doThis` method, since the lambda expression returns nothing (just prints the `String` `"executing"`), the compiler understands that this lambda expression is an implementation of the `Executable` interface, because the `execute` also returns nothing. -. Se não for possível descobrir o tipo da expressão lambda, ocorre erro de compilação. +. If the type of the lambda expression cannot be found, a compilation error occurs. + [source,java,indent=0] .{java-package}/lambdaexpression/LambdaExpression_Ambiguity.java @@ -164,14 +162,14 @@ Na segunda chamada ao método `rode`, como a expressão lambda não retorna nada 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. +In the previous example, because both functional interfaces have a `void` method, the compiler does not know which one is being instantiated in the lambda expression, and a compilation error occurs. The lambda expression in this example could be either `Pilot` or `Runner`, and there is no way for the compiler to find out which developer actually wanted to use it. -.Referências +.References **** * 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. +Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 55). Wiley. Kindle Edition. * Using Variables in Lambdas + @@ -181,4 +179,4 @@ Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 * https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html[Lambda Expressions.] The Java™ Tutorials. -**** \ No newline at end of file +**** diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AccessExternalVar.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AccessExternalVar.java index 37cbb03..606610b 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AccessExternalVar.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AccessExternalVar.java @@ -10,16 +10,16 @@ public static void main(String[] args) { Double x2 = 2.0; Double x3 = 2.0; - // COMPILA - variável externa 'x1' é final e pode ser utilizada na expressão lambda - UnaryOperator elevarAoX1 = (Double y) -> Math.pow(y, x1); + // COMPILES - external variable 'x1' is final and can be used in lambda expression + UnaryOperator raiseToX1 = (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 elevarAoX2 = (Double y) -> Math.pow(y, x2); + // COMPILES - external variable 'x2' is not final, but never changed, so it can be used inside the lambda expression + UnaryOperator raiseToX2 = (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 elevarAoX3 = (Double y) -> Math.pow(y, x3); + // NOT COMPILING - external variable 'x3' is changed within this method, so it cannot be used within the lambda expression + UnaryOperator raiseToX3 = (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 + x3 = 3.0; // changing variable 'x3' does not allow it to be used in lambda expressions } // end::code[] } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Ambiguity.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Ambiguity.java index 3dc6d68..14a7dab 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Ambiguity.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Ambiguity.java @@ -4,29 +4,29 @@ public class LambdaExpression_Ambiguity { // tag::code[] @FunctionalInterface - interface Corredor { - void corra(); + interface Runner { + void run(); } @FunctionalInterface - interface Piloto { - void corra(); + interface Pilot { + void run(); } static class Executor { - void execute(Corredor corredor) { - corredor.corra(); + void execute(Runner runner) { + runner.run(); } - String execute(Piloto piloto) { - piloto.corra(); - return "correndo"; + String execute(Pilot pilot) { + pilot.run(); + return "running"; } } 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 + // NOT COMPILING - cannot determine type of lambda expression below executor.execute(() -> System.out.println("execute")); } // end::code[] diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AnonymousClass.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AnonymousClass.java index 99d6dfc..7b9aa7b 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AnonymousClass.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_AnonymousClass.java @@ -4,16 +4,16 @@ public class LambdaExpression_AnonymousClass { public static void main(String[] args) { // tag::code[] - // com classe anônima + // with anonymous class new Thread(new Runnable() { @Override public void run() { - System.out.println("Executando."); + System.out.println("Executing."); } }).run(); - // com expressão lambda - new Thread(() -> System.out.println("Executando.")).run(); + // with lambda expression + new Thread(() -> System.out.println("Executing.")).run(); // end::code[] } } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Block.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Block.java index 8f37b98..752e392 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Block.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Block.java @@ -7,12 +7,12 @@ public class LambdaExpression_Block { public static void main(String[] args) { // tag::code[] - UnaryOperator elevarAoQuadrado = (Double x) -> { + UnaryOperator square = (Double x) -> { double pow = Math.pow(x, 2); return pow; }; - Consumer imprime = (Double x) -> { + Consumer print = (Double x) -> { double pow = Math.pow(x, 2); System.out.println(pow); }; diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_ForEach.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_ForEach.java index 36eab1c..da08b65 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_ForEach.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_ForEach.java @@ -7,8 +7,8 @@ public class LambdaExpression_ForEach { public static void main(String[] args) { // tag::code[] - List lista = Arrays.asList(1, 2, 3, 4, 5); - lista.forEach((numero) -> { System.out.println(numero); }); + List list = Arrays.asList(1, 2, 3, 4, 5); + list.forEach((number) -> { System.out.println(number); }); // end::code[] } } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_FunctionalInterface.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_FunctionalInterface.java index d740ff4..8bfaa09 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_FunctionalInterface.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_FunctionalInterface.java @@ -4,27 +4,27 @@ public class LambdaExpression_FunctionalInterface { // tag::code[] @FunctionalInterface - interface Executavel { // interface funcional - String execute(); // método funcional + interface Executable { // functional interface + String execute(); // functional method } - private static void executeEApresenteMensagem(Executavel executavel) { - String mensagem = executavel.execute(); - System.out.println(mensagem); + private static void executeAndPresentMessage(Executable executable) { + String message = executable.execute(); + System.out.println(message); } public static void main(String[] args) { - // com classe anônima - executeEApresenteMensagem(new Executavel() { + // with anonymous class + executeAndPresentMessage(new Executable() { @Override public String execute() { - return "executei com classe anônima"; + return "performed with anonymous class"; } }); - // com expressão lambda - executeEApresenteMensagem(() -> { return "executei com expressão lambda"; }); + // with lambda expression + executeAndPresentMessage(() -> { return "performed with lambda expression"; }); } // end::code[] } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Parenthesis.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Parenthesis.java index 6fce476..5188a21 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Parenthesis.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Parenthesis.java @@ -1,25 +1,27 @@ package org.j6toj8.lambda.lambdaexpression; +import java.util.function.BinaryOperator; +import java.util.function.Supplier; 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 elevarAoQuadrado = Double x -> Math.pow(x, 2); + // NOT COMPILING - parentheses are required when declaring the type of the lambda expression variable + UnaryOperator square = 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 elevarAoX = y, x -> Math.pow(y, x); + // NOT COMPILING - parentheses are required when there is more than one variable in the lambda expression + BinaryOperator raiseToX = y, x -> Math.pow(y, x); - // NÃO COMPILA - é obrigatório utilizar parênteses quando não há variáveis - Supplier elevar2aoQuadrado = -> Math.pow(2, 2); + // NOT COMPILING - parentheses are required when there are no variables + Supplier square2 = -> Math.pow(2, 2); - // COMPILA - parênteses vazios quando não há variáveis - Supplier elevar2aoQuadrado = () -> Math.pow(2, 2); + // COMPILES - empty parentheses when there are no variables + Supplier square3 = () -> Math.pow(2, 2); - // COMPILA - sem parênteses quando há apenas uma variável e não escrevemos seu tipo - UnaryOperator elevarAoQuadrado2 = x -> Math.pow(x, 2); + // COMPILES - no parentheses when there's only one variable and we don't write its type + UnaryOperator square4 = x -> Math.pow(x, 2); // end::code[] } } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Shadowing.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Shadowing.java index f88957e..a538b01 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Shadowing.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_Shadowing.java @@ -7,13 +7,13 @@ public class LambdaExpression_Shadowing { // tag::code[] public static void main(String[] args) { - Double x = 2.0; // variável 'x' no método + Double x = 2.0; // 'x' variable in method - // 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 elevarAoX = (Double y, Double x) -> Math.pow(y, x); + // NOT COMPILING - variable named 'x' already exists and cannot be declared in lambda expression variables + BinaryOperator raiseToX = (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 elevarAoQuadrado = (Double y) -> { + // NOT COMPILING - variable named 'x' already exists and cannot be declared in lambda expression body + UnaryOperator square = (Double y) -> { Double x = 2.0; return Math.pow(y, x); }; diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_SimpleComplete.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_SimpleComplete.java index 46c2f66..39fe588 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_SimpleComplete.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_SimpleComplete.java @@ -6,10 +6,10 @@ public class LambdaExpression_SimpleComplete { public static void main(String[] args) { // tag::code[] - // expressão lambda completa - UnaryOperator elevarAoQuadrado1 = (Double x) -> { return Math.pow(x, 2); }; - // expressão lambda simplificada - UnaryOperator elevarAoQuadrado2 = (x) -> Math.pow(x, 2); + // complete lambda expression + UnaryOperator square1 = (Double x) -> { return Math.pow(x, 2); }; + // simplified lambda expression + UnaryOperator square2 = (x) -> Math.pow(x, 2); // end::code[] } } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_TypeInference.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_TypeInference.java index ff59016..51d587c 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_TypeInference.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_TypeInference.java @@ -4,31 +4,31 @@ public class LambdaExpression_TypeInference { // tag::code[] @FunctionalInterface - interface Executavel { - void execute(); // método funcional sem argumentos + interface Executable { + void execute(); // functional method without arguments } @FunctionalInterface interface Application { - String run(); // método funcional também sem argumentos + String run(); // functional method also without arguments } static class Executor { - // esse método pode receber uma expressão lambda sem argumentos - void rode(Executavel executavel) { - executavel.execute(); + // this method can get a lambda expression with no arguments + void doThis(Executable executable) { + executable.execute(); } - // esse método também pode receber uma expressão lambda sem argumentos - void rode(Application application) { + // this method can also get a lambda expression without arguments + void doThis(Application application) { application.run(); } } public static void main(String[] args) { Executor executor = new Executor(); - 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 + executor.doThis(() -> { return "executing"; }); // will call execute that receives an Application + executor.doThis(() -> { System.out.println("executing"); }); // will call execute that gets an Executable } // end::code[] } diff --git a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_VarType.java b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_VarType.java index 07f6dd3..5deaf0f 100644 --- a/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_VarType.java +++ b/src/org/j6toj8/lambda/lambdaexpression/LambdaExpression_VarType.java @@ -1,16 +1,16 @@ package org.j6toj8.lambda.lambdaexpression; -import java.util.function.UnaryOperator; +import java.util.function.BinaryOperator; 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 elevarAoX = (Double y, x) -> Math.pow(y, x); + // NOT COMPILING - if the type of one of the parameters is entered, all of them must be entered. + BinaryOperator raiseToX = (Double y, x) -> Math.pow(y, x); - // COMPILA - todos os parâmetros com tipos informados - UnaryOperator elevarAoX2 = (Double y, Double x) -> Math.pow(y, x); + // COMPILES - all parameters with informed types + BinaryOperator raiseToX2 = (Double y, Double x) -> Math.pow(y, x); // end::code[] } }