Expresiones Lambda

A partir de Java 8, se introdujo el soporte a la programación funcional gracias a las Expresiones Lambda. Una lambda es esencialmente un método anónimo (una función sin nombre) que se puede pasar como argumento a métodos o almacenar en variables.

Las Interfaces Funcionales

Una expresión lambda solo se puede usar donde se requiera una Interfaz Funcional (Functional Interface). Se trata de una interfaz que declara un solo método abstracto. Java marca estas interfaces con la anotación opcional @FunctionalInterface.

Ejemplo de interfaz funcional definida por el usuario:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

Antes de Java 8, habríamos tenido que definir una clase anónima. Con las lambdas, la sintaxis se reduce a:

MathOperation addition = (a, b) -> a + b;
int result = addition.operate(5, 3); // Ritorna 8

Estructura de las Expresiones Lambda

La sintaxis básica de una lambda es:

(parametri) -> { corpo }

• Sin parámetros: () -> System.out.println("Hello")
• Un solo parámetro: x -> x * 2 (se pueden omitir los paréntesis)
• Múltiples parámetros: (x, y) -> x + y
• Cuerpo multilínea: si el cuerpo contiene varias instrucciones, se necesitan llaves {} y la instrucción return explícita.

MathOperation detailedAddition = (a, b) -> {
    System.out.println("Somma in corso...");
    return a + b;
};

Interfaces Funcionales Estándar en Java

El paquete java.util.function proporciona muchas interfaces funcionales predefinidas:

• Predicate<T>: acepta un argumento de tipo T y devuelve un booleano (método test(T t)).
• Consumer<T>: acepta un argumento de tipo T y realiza una operación sin devolver nada (método accept(T t)).
• Function<T, R>: acepta un argumento T y devuelve un resultado R (método apply(T t)).
• Supplier<T>: no acepta argumentos y devuelve un valor T (método get()).

Pruébalo tú