Expresiones Lambda en java 8 - Magia básica

Una EXPRESIÓN LAMBDA se parece mucho a la declaración e implementación de un método, así que podemos considerar las expresiones LAMBDA como métodos anónimos o métodos sin un nombre.

 

Una expresión lambda tiene las siguientes características:

1. Un listado de parámetros separados por una coma y encerrados en paréntesis:

   a) Puedes omitir el tipo de dato de cada parámetro.

   b) Si solo hay 1 parámetro también puedes omitir el uso de los paréntesis.

   La expresión: p -> p.getNombrePersona() es correcta; también puedes utilizarla de esta forma: (Persona p) -> p.getNombrePersona()

2. El token de flecha que está compuesto por un guión y el signo de mayor que: ->

3. El cuerpo de la expresión que básicamente es la implementación del método que se quiere ejecutar; puede ser una sentencia simple o un bloque encerrado en {} .

   Si utilizas una sentencia simple puedes omitir la palabra "return" y el runtime de java evalúa la expresión y devuelve el resultado.

 

IMPORTANTE: Te puedes descargar el código directamente del repositorio en github o en formato zip.

 

Ejemplos de expresiones lambda:

1. Código java de una interfaz con únicamente 1 método que no recibe parámetros y no devuelve nada (void):

/**
* Código generado por Gerado Pucheta Figueroa
* Twitter: @ledzedev
* http://ledze.mx
* 11/03/2017.
*/
public interface MiPrimerLambda {

void metodoSinParametros();
}

 

2. Código java de una interfaz con únicamente 1 método que recibe 2 parámetros int y devuelve otro int.

/**
* Código generado por Gerado Pucheta Figueroa
* Twitter: @ledzedev
* http://ledze.mx
* 11/03/2017.
*/
public interface OperacionBasicaLambda {

int operacion(int a, int b);
}

3. Código java de una clase que utiliza de distintas formas las interfaces primero con implementaciones antiguas y luego utilizando expresiones lamda.

public static void main(String[] args) {

//Iniciamos con una interfaz cuyo único método no devuelve nada y no tiene parámetros
//la implementación es anónima simulando un lambda.
MiPrimerLambda miPrimerLambdaDeclaracionAnonima = new MiPrimerLambda() {

@Override
public void metodoSinParametros() {

System.out.println("Hola mundo ledze con declaración anónima.");
}
};
miPrimerLambdaDeclaracionAnonima.metodoSinParametros();
System.out.println("/***********************************/");

//Ahora el mismo método es implementado con el paradigma de los lambdas.
MiPrimerLambda miPrimerLambda = () -> System.out.println("Hola mundo ledze con lambdas.");

miPrimerLambda.metodoSinParametros();

System.out.println("/***********************************/");

//Aquí tenemos 4 objetos del mismo tipo con diferente implementación.
OperacionBasicaLambda opSuma = (a,b) -> a+b;

OperacionBasicaLambda opResta = (a,b) -> a-b;
OperacionBasicaLambda opMultiplica = (a,b) -> a*b;
OperacionBasicaLambda opDivide = (a,b) -> (int)(a/b);

int resultadoSuma = opSuma.operacion(5,5);
int resultadoResta = opResta.operacion(5,5);
int resultadoMultiplica = opMultiplica.operacion(5,5);
int resultadoDivide = opDivide.operacion(5,5);

System.out.println("Lambda ledze: Misma clase, distinto objeto diferente implementación. Resultado suma = "+resultadoSuma);
System.out.println("Lambda ledze: Misma clase, distinto objeto diferente implementación. Resultado resta = "+resultadoResta);
System.out.println("Lambda ledze: Misma clase, distinto objeto diferente implementación. Resultado multiplicación = "+resultadoMultiplica);
System.out.println("Lambda ledze: Misma clase, distinto objeto diferente implementación. Resultado división = "+resultadoDivide);
System.out.println("/***********************************/");

//También puedes sobre-escribir el método para que se ejecute tu implementación.
OperacionBasicaLambda opGenerica;


opGenerica = (a,b) -> a+b;
System.out.println("Lambda ledze: Mismo objeto con diferente implementación. Resultado = "+opGenerica.operacion(10,2));
opGenerica = (a,b) -> a-b;
System.out.println("Lambda ledze: Mismo objeto con diferente implementación. Resultado = "+opGenerica.operacion(10,2));
opGenerica = (a,b) -> a*b;
System.out.println("Lambda ledze: Mismo objeto con diferente implementación. Resultado = "+opGenerica.operacion(10,2));
opGenerica = (a,b) -> a/b;
System.out.println("Lambda ledze: Mismo objeto con diferente implementación. Resultado = "+opGenerica.operacion(10,2));
}

Concluyendo

Podemos ver claramente que las expresiones lambda nos facilitan la vida para realizar implementaciones independientes y para evitar el uso de clases anónimas en nuestro código fuente.

Como ya lo mencioné, podemos considerar las expresiones LAMBDA como métodos anónimos o métodos sin un nombre.

El resultaddo de ejecutar el código expuesto es el siguiente.