Expresiones Lambda en java 8 - Magia básica
- Details
- Created: Monday, 13 March 2017 06:22
- Written by Gerardo Pucheta Figueroa
- Hits: 705
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.
Add a comment