Java Lambda 表达式

Java 8 Nuevas características

La expresión lambda, también conocida como clausura, es un motor que impulsa a Java 8 la característica nueva más importante lanzada.

Lambda permite pasar una función como un parámetro de un método (pasar una función como parámetro a un método).

El uso de expresiones lambda puede hacer que el código sea más conciso y compacto.

Sintaxis

El formato de sintaxis de la expresión lambda es el siguiente:

(parámetros)　->    expresión
o
(parámetros)　-{    statements;    }

A continuación se presentan las características importantes de la expresión lambda:

• Declaración de tipo opcional:No es necesario declarar el tipo de parámetro, el compilador puede identificar los valores de los parámetros de manera unificada.

• Paréntesis de parámetros opcionales:Un solo parámetro no requiere paréntesis redondos, pero varios parámetros necesitan definirlos.

• Llaves opcionales:Si el cuerpo contiene una instrucción, no es necesario usar llaves.

• Palabra clave de retorno opcional:Si el cuerpo de la expresión lambda tiene solo una expresión, el compilador devolverá automáticamente el valor, y los corchetes deben especificar claramente que la expresión devuelve un valor numérico.

Ejemplo de expresión lambda

Ejemplo simple de expresión lambda:

//　1. no requiere parámetros, el valor de retorno es　5　　
()　->　5　　
　　
//　2. acepta un parámetro (tipo numérico) y devuelve su2el valor multiplicado　　
x　->　2　*　x　　
　　
//　3. acepta2dos parámetros (números) y devuelve su diferencia　　
(x, y)　-> x - y　　
　　
//　4. acepta2dos enteros int, devuelve su suma　　
(int x, int y)　-> x　+　y　　
　　
//　5. acepta un objeto string y lo imprime en la consola, sin devolver ningún valor (parece que devuelve void)　　
(String s)　-> System.out.print(s)

En Java8Escriba el siguiente código en el archivo Tester.java:

public class Java8Tester {
　　　public static void main(String args[]){
　　　　　　Java8Tester tester = new Java8Tester();
　　　　　　　　
　　　　　　//　declaración de tipo
　　　　　　MathOperation adición = (int a, int b)　-> a　+　b;
　　　　　　　　
　　　　　　//　sin declaración de tipo
　　　　　　MathOperation sustracción = (a, b)　-> a　-　b;
　　　　　　　　
　　　　　　//　instrucción de retorno dentro de llaves
　　　　　　MathOperation multiplicación = (int a, int b)　-> { return a　*　b; };
　　　　　　　　
　　　　　　//　sin llaves ni instrucción de retorno
　　　　　　MathOperation división = (int a, int b)　-> a　/　b;
　　　　　　　　
　　　　　　System.out.println("10　+　5　= "　+　tester.operate(10,　5, adición));
　　　　　　System.out.println("10　-　5　= "　+　tester.operate(10,　5, sustracción));
　　　　　　System.out.println("10　x　5　= "　+　tester.operate(10,　5, multiplicación));
　　　　　　System.out.println("10　/　5　= "　+　tester.operate(10,　5, división));
　　　　　　　　
　　　　　　//　no usar paréntesis
　　　　　　GreetingService greetService1　= message　->
　　　　　　System.out.println("Hello "　+　message);
　　　　　　　　
　　　　　　//　usar paréntesis
　　　　　　GreetingService greetService2　= (message)　->
　　　　　　System.out.println("Hello "　+　message);
　　　　　　　　
　　　　　　greetService13codebox');
　　　　　　greetService2.sayMessage("Google");
　　　}
　　　　
　　　interface MathOperation {
　　　　　　int operation(int a, int b);
　　　}
　　　　
　　　interface GreetingService {
　　　　　　void sayMessage(String message);
　　　}
　　　　
　　　private int operate(int a, int b, MathOperation mathOperation) {
　　　　　　return mathOperation.operation(a, b);
　　　}
}

Ejecutando el script anterior, el resultado de la salida es:

$ javac Java8Tester.java　
$ java Java8Tester
10　+　5　=　15
10　-　5　=　5
10　x　5　=　50
10　/　5　=　2
¡Hola w3codebox
¡Hola Google!

Al usar expresiones lambda, hay dos puntos que应注意:

• Las expresiones lambda se utilizan principalmente para definir interfaces de métodos que se ejecutan en línea, como una interfaz de método simple. En este ejemplo, usamos varios tipos de expresiones lambda para definir el método de la interfaz MathOperation. Luego definimos la ejecución de sayMessage.

• Las expresiones lambda evitan la molestia de usar métodos anónimos y proporcionan a Java la capacidad de programación funcional simple pero poderosa.

Ámbito de las variables

Las expresiones lambda solo pueden referir a variables locales etiquetadas como final en el exterior, lo que significa que no se puede modificar la variable local definida en el dominio exterior dentro de la lambda, de lo contrario se producirá un error de compilación.

En Java8Escriba el siguiente código en el archivo Tester.java:

public class Java8Tester {
　
　　　final static String salutation = "¡Hola! ";
　　　
　　　public static void main(String args[]){
　　　　　　GreetingService greetService1　= message　->　
　　　　　　System.out.println(salutation　+　message);
　　　　　　greetService13codebox');
　　　}
　　　　
　　　interface GreetingService {
　　　　　　void sayMessage(String message);
　　　}
}

Ejecutando el script anterior, el resultado de la salida es:

$ javac Java8Tester.java　
$ java Java8Tester
¡Hola! w3codebox

También podemos acceder directamente a las variables locales externas en la expresión lambda:

public class Java8Tester {
　　　　public static void main(String args[]) {
　　　　　　　　final int num =　1;
　　　　　　　　Converter<Integer,　String>　s　=　(param)　->　System.out.println(String.valueOf(param　+　num));
　　　　　　　　s.convert(2);　　//　El resultado de la salida es　3
　　　　}
　
　　　　public interface Converter<T1, T2> {
　　　　　　　　void convert(int i);
　　　　}
}

Las variables locales de expresiones lambda no necesitan declararse como final, pero deben ser inmutables para el código posterior (es decir, tienen el significado implícito de final)

int　num　=　1;　　
Converter<Integer,　String>　s　=　(param)　->　System.out.println(String.valueOf(param　+　num));
s.convert(2);
num　=　5;　　
//Mensaje de error: La variable local num definida en un ámbito encerrado debe ser final o efectivamente　
　final

No se permite declarar un parámetro o variable local con el mismo nombre que una variable local en una expresión Lambda.

String　first　=　"";　　
Comparator<String>　comparator　=　(first,　second)　->　Integer.compare(first.length(),　second.length());　　//La compilación generará errores

Java 8 Nuevas características