Tutorial de expresiones Java Lambda con ejemplos

La expresión lambda es una nueva característica introducida en Java 8. Una expresión lambda es una función anónima. Una función que no tiene nombre y no pertenece a ninguna clase. El concepto de expresión lambda se introdujo por primera vez en el lenguaje de programación LISP.

Sintaxis de la expresión Java Lambda

Para crear una expresión lambda, especificamos los parámetros de entrada (si los hay) en el lado izquierdo del operador lambda -> y colocamos el bloque de expresión o declaración en el lado derecho del operador lambda. Por ejemplo, la expresión lambda (x, y) -> x + y especifica que la expresión lambda toma dos argumentos xey y devuelve la suma de estos.

//Syntax of lambda expression
(parameter_list) -> {function_body}

Expresión lambda vs método en Java

Un método (o función) en Java tiene estas partes principales:
1. Nombre
2. Lista de parámetros
3. Cuerpo
4. tipo de retorno.

Una expresión lambda en Java tiene estas partes principales:
Expresión lambda solo tiene el cuerpo y la lista de parámetros.
1. No nombre: la función es anónima, por lo que no nos importa el nombre
2. Lista de parámetros
3. Cuerpo: esta es la parte principal de la función.
4. No tipo de retorno: el compilador de Java 8 puede deducir el tipo de retorno comprobando el código. no es necesario mencionarlo explícitamente.

Dónde usar Lambda en Java

Para utilizar la expresión lambda, debe crear su propia interfaz funcional o utilizar la interfaz funcional predeterminada proporcionada por Java. Una interfaz con método abstracto único único se llama interfaz funcional (o interfaz de método abstracto único), por ejemplo: Ejecutable, invocable, ActionListener, etc.

Para utilizar la interfaz de funciones:

Pre Java 8: creamos clases internas anónimas.
Publicar Java 8: puede usar la expresión lambda en lugar de clases internas anónimas.

Ejemplo de expresión Java Lambda

Sin usar la expresión Lambda: Antes de Java 8, usábamos la clase interna anónima para implementar el único método de interfaz funcional abstracto.

import java.awt.*;  
import java.awt.event.*;  
public class ButtonListenerOldWay {  
    public static void main(String[] args) {  
       Frame frame=new Frame("ActionListener Before Java8");  
    
       Button b=new Button("Click Here");  
       b.setBounds(50,100,80,50);  
  
       b.addActionListener(new ActionListener(){  
          public void actionPerformed(ActionEvent e){  
    	     System.out.println("Hello World!"); 
          }  
       });  
       frame.add(b);
    
       frame.setSize(200,200);  
       frame.setLayout(null);  
       frame.setVisible(true);   
    }  
}

Usando la expresión Lambda: En lugar de crear una clase interna anónima, podemos crear una expresión lambda como esta:

import java.awt.*;  
public class ButtonListenerNewWay {  
   public static void main(String[] args) {  
      Frame frame=new Frame("ActionListener java8");  
     
      Button b=new Button("Click Here");  
      b.setBounds(50,100,80,50); 
  
      b.addActionListener(e -> System.out.println("Hello World!")); 
      frame.add(b);
  
      frame.setSize(200,200);  
      frame.setLayout(null);  
      frame.setVisible(true);   
   }  
}

Nota:

1. Como puede ver, hemos usado menos código con la expresión lambda.
2. Compatibilidad con versiones anteriores: puede utilizar la expresión lambda con el código antiguo. Lambda es compatible con versiones anteriores, por lo que puede usarlos en su API existente al migrar su proyecto a java 8.

Veamos algunos otros ejemplos de expresiones Lambda.

Ejemplo 1: Expresión Java Lambda sin parámetros

@FunctionalInterface
interface MyFunctionalInterface {

	//A method with no parameter
    public String sayHello();
}
public class Example {

   public static void main(String args[]) {
        // lambda expression
    	MyFunctionalInterface msg = () -> {
    		return "Hello";
    	};
        System.out.println(msg.sayHello());
    }
}

Producción:

Hello

Ejemplo 2: Expresión Java Lambda con un solo parámetro

@FunctionalInterface
interface MyFunctionalInterface {

	//A method with single parameter
    public int incrementByFive(int a);
}
public class Example {

   public static void main(String args[]) {
        // lambda expression with single parameter num
    	MyFunctionalInterface f = (num) -> num+5;
        System.out.println(f.incrementByFive(22));
    }
}

Producción:

27

Ejemplo 3: expresión Java Lambda con varios parámetros

interface StringConcat {

    public String sconcat(String a, String b);
}
public class Example {

   public static void main(String args[]) {
        // lambda expression with multiple arguments
    	StringConcat s = (str1, str2) -> str1 + str2;
        System.out.println("Result: "+s.sconcat("Hello ", "World"));
    }
}

Producción:

Result: Hello World

Ejemplo 4: colecciones repetidas usando el bucle foreach

import java.util.*;  
public class Example{  
    public static void main(String[] args) {       
       List<String> list=new ArrayList<String>();  
       list.add("Rick");         
       list.add("Negan");       
       list.add("Daryl");         
       list.add("Glenn");         
       list.add("Carl");                
       list.forEach(          
           // lambda expression        
           (names)->System.out.println(names)         
       );     
    }  
}

Podemos iterar mapas y otras clases de colección usando expresión lambda, consulte esta guía: Iterando mapa y lista usando expresión lambda