¿Qué son las expresiones Lambda?

Las expresiones lambda representan una mejora importante en Java, introducidas para simplificar la escritura de código, especialmente cuando se trabaja con interfaces que tienen un único método abstracto, conocidas como interfaces funcionales.

• Una lambda es una función aónima que se puede usar para implementar un método de una interfaz funcional.
• Evitan la necesidad de crear clases anónimas verbosas.
• Se basan en el paradigma de programación funcional.

La sintaxis básica de una lambda es:

(parametros) -> { expresion; }

O en su forma más simple:

(param) -> expresion

Interfaces funcionales

Una interfaz funcionall es aquella que tiene exactamente un método abstracto. Por ejemplo:

public interface Runnable {
    public abstract void run();
}

Las lambdas permiten crear una instancia de una interfaz funcional sin tener que implementarla explícitamente.
Regla de simplificación: Solo se pueden omitir las llaves {} cuando el cuerpo de la lambda tiene una sola línea. Los paréntesis () se pueden omitir solo cuando hay un único parámetro.

Ejemplo práctico: Simplificación progresiva de una lambda

En el siguiente código, veremos cómo evoluciona una expresión lambda desde su forma más completa hasta su versión más simplificada:

package com.ejemplo.lambda;

public class LambdaSimplificacion {

    // Clase interna estática que implementa la interfaz
    static class MiEjemplo02 implements Ejemplo{
        @Override
        public void ejecutar(String mensaje) {
            System.out.println(" Mensaje 02! " + mensaje);
        }
    }

    public static void main(String args[]) {

        // Instancia con implementación clásica
        Ejemplo obj = new MiEjemplo01();
        obj.ejecutar("Java");

        // Usando la clase estática interna
        obj = new MiEjemplo02();
        obj.ejecutar("Java");

        // Clase local (interna al método)
        class MiEjemplo03 implements Ejemplo{
            @Override
            public void ejecutar(String mensaje) {
                System.out.println(" Mensaje 03! " + mensaje);
            }
        }
        obj = new MiEjemplo03();
        obj.ejecutar("Java");

        // Clase anónima
        obj = new Ejemplo() {
            public void ejecutar(String mensaje) {
                System.out.println(" Mensaje 04! " + mensaje);
            }
        };
        obj.ejecutar("Java");

        // Lambda forma completa
        obj = (String mensaje) -> {
            System.out.println(" Mensaje 05! " + mensaje);
        };
        obj.ejecutar("Java");

        // Lambda simplificada 01: eliminar tipo de parámetro
        obj = (mensaje) -> {
            System.out.println(" Mensaje 06! " + mensaje);
        };
        obj.ejecutar("Java");

        // Lambda simplificada 02: eliminar paréntesis (solo si hay un parámetro)
        obj = mensaje -> {
            System.out.println(" Mensaje 07! " + mensaje);
        };
        obj.ejecutar("Java");

        // Lambda simplificada 03: eliminar llaves (solo si hay una línea)
        obj = mensagem ->
            System.out.println(" Mensaje 08! " + mensagem);
        obj.ejecutar("Java");
    }
}

// Implementación clásica de la interfaz
class MiEjemplo01 implements Ejemplo{
    @Override
    public void ejecutar(String mensaje) {
        System.out.println(" Mensaje 01! " + mensaje);
    }
}

// Interfaz funcional con un solo método abstracto
interface Ejemplo{
    public abstract void ejecutar(String mensaje);
}

/* Salida esperada:
 Mensaje 01! Java
 Mensaje 02! Java
 Mensaje 03! Java
 Mensaje 04! Java
 Mensaje 05! Java
 Mensaje 06! Java
 Mensaje 07! Java
 Mensaje 08! Java
*/

Como se puede observar, la progresión muestra cómo reducir el código manteniendo la misma funcionalidad. Esta es la esencia de las expresiones lambda en Java.