Skip to content

7. Interfaces funcionales, lambdas y eventos

En muchos programas necesitamos pasar a un método no datos sino comportamiento: el criterio de ordenación, la condición de filtrado o el procesamiento que se debe realizar cuando ocurre algo. Java responde a esta necesidad con un concepto sencillo en el que se basa todo este capítulo: la interfaz funcional, es decir, una interfaz que declara un único método abstracto. Un objeto que implementa una interfaz de este tipo “lleva” una función, que puede almacenarse en una variable, pasarse como parámetro, devolverse como resultado de un método y ejecutarse a voluntad.

Antes de Java 8 (2014), había que escribir una clase —a menudo una clase anónima— por cada comportamiento que se quería expresar, lo cual era verboso. Java 8 introdujo las expresiones lambda y las referencias a métodos, que permiten escribir este comportamiento en una sola línea. Ya las hemos usado sin entrar en detalles con la API Stream en el capítulo 5: en [persons.stream().filter(p -> p.age() >= 18)], pasamos una lambda —es decir, una instancia de una interfaz funcional— al método [filter]. Este capítulo explica lo que hay detrás de esta sintaxis. Concluye con los eventos, que Java maneja mediante “listeners”: objetos —a menudo lambdas— que se registran en un emisor para ser notificados de lo que ocurre en él. Las interfaces gráficas de usuario de Java (Swing, JavaFX) y los frameworks web se basan por igual en este mecanismo: un clic en un botón o la llegada de una solicitud (HTTP) se señalan a los listeners registrados. Este curso no trata las interfaces gráficas de usuario; todos los ejemplos son programas de consola.

Los programas de este capítulo son archivos fuente compactos ubicados en la carpeta [07-lambdas]. Se ejecutan con [java LambdasNN.java]. Observe que un archivo fuente compacto importa automáticamente todo el módulo [java.base]: las interfaces de los paquetes [java.util.function], [java.util] o [java.util.concurrent] pueden usarse allí sin ninguna instrucción [import].

7.1. Interfaces funcionales predefinidas

7.1.1. El concepto de interfaz funcional

Una interfaz funcional es una interfaz que tiene exactamente un método abstracto. También puede tener tantos métodos [default] y [static] como se desee (véase el capítulo 4): estos no cuentan. Este único método abstracto describe un modelo (también llamado firma o forma) de una función: los tipos de sus parámetros y el tipo de su valor de retorno. Una variable del tipo de la interfaz puede entonces referirse a cualquier objeto que proporcione una función de esta forma y ejecutarla llamando al método.

El ejemplo más antiguo es la interfaz [java.lang.Runnable], que existe desde Java 1.0 y representa una tarea que se debe ejecutar (volveremos a ella a propósito de los hilos en el capítulo 8). Consta de un único método: [void run();]. Describe una función:

  • sin parámetros;
  • que no devuelve ningún resultado ([void]).

Hay tres maneras de crear un objeto de tipo [Runnable]:

  • escribir una clase que implemente la interfaz, ya sea con nombre o anónima. Esta era la única forma de hacerlo antes de Java 8;
  • escribir una expresión lambda: [Runnable task = () -> IO.println("task");];
  • escribir una referencia a método a un método existente que tenga la forma correcta: [Runnable task = Functions::display;].

En los dos últimos casos, el compilador crea por sí mismo el objeto que implementa la interfaz: la lambda o el método referenciado se convierte en el cuerpo del método [run]. La función se ejecuta entonces llamando al método de la interfaz: [task.run()]. A diferencia de otros lenguajes, Java no tiene una sintaxis de llamada específica: el método de la interfaz siempre se llama por su nombre ([run], [apply], [test]…).

7.1.2. Interfaces del paquete java.util.function

Antes de Java 8, cada biblioteca definía sus propias interfaces de un solo método ([Runnable], [Comparator], [ActionListener]…). Java 8 introdujo el paquete [java.util.function], que proporciona 43 interfaces funcionales genéricas que cubren prácticamente todas las necesidades. Las principales son las siguientes:

Interfaz
Método abstracto
Funciones representadas
[Runnable] ([java.lang])
[void run()]
Sin parámetros, sin resultado
[Supplier<T>]
[T get()]
Sin parámetros, un resultado: un “proveedor” (supplier)
[Consumer<T>]
[void accept(T t)]
Un parámetro, sin resultado: un “consumidor” (consumer)
[BiConsumer<T, U>]
[void accept(T t, U u)]
Dos parámetros, sin resultado
[Function<T, R>]
[R apply(T t)]
Un parámetro, un resultado de tipo [R] (siempre el último tipo)
[BiFunction<T, U, R>]
[R apply(T t, U u)]
Dos parámetros, un resultado
[UnaryOperator<T>]
[T apply(T t)]
Una [Function<T, T>]: parámetro y resultado del mismo tipo
[BinaryOperator<T>]
[T apply(T t1, T t2)]
Una [BiFunction<T, T, T>]
[Predicate<T>]
[boolean test(T t)]
Un parámetro, un resultado booleano: un “predicado” (predicate)
[BiPredicate<T, U>]
[boolean test(T t, U u)]
Dos parámetros, un resultado booleano
[Comparator<T>] ([java.util])
[int compare(T o1, T o2)]
Dos parámetros del mismo tipo, un resultado entero
[Callable<V>] ([java.util.concurrent])
[V call() throws Exception]
Igual que [Supplier<V>], pero puede lanzar una excepción verificada

Los genéricos de Java se aplican solo a tipos de objeto: una [Function<Integer, Integer>] recibe y devuelve [Integer], lo que requiere conversiones automáticas (boxing y unboxing) entre [int] e [Integer]. Para evitarlas, el paquete proporciona versiones especializadas para los tipos primitivos [int], [long] y [double]: [IntBinaryOperator] ([int applyAsInt(int left, int right)]), [IntUnaryOperator], [IntPredicate], [IntSupplier], [IntConsumer], [IntFunction<R>] (con [int] como parámetro), [ToIntFunction<T>] (con [int] como resultado) y sus equivalentes [Long…] y [Double…]. No hay ninguna interfaz predefinida con tres o más parámetros; en ese caso, debe definir la suya propia (véase el párrafo siguiente).

El programa [Lambdas01.java] usa estas interfaces con referencias a métodos:

// las interfaces funcionales predefinidas de Java

void main() {
    // 1 - Runnable: sin parámetro, sin resultado: void run()
    Runnable task = new Runnable() {
        @Override
        public void run() {
            Functions.display();
        }
    };
    // forma abreviada: una referencia a método
    task = Functions::display;
    // ejecución: llamamos al único método abstracto de la interfaz
    task.run();

    // 2 - BiFunction<T, U, R>: dos parámetros, un resultado
    BiFunction<Integer, Integer, Integer> operation = Functions::add;
    IO.println("operation.apply(2, 3)=" + operation.apply(2, 3));
    // Supplier<T>: sin parámetro, un resultado
    Supplier<String> greet = Functions::greet;
    IO.println("greet.get()=" + greet.get());
    // versión primitiva: IntBinaryOperator, int applyAsInt(int, int), sin boxing
    IntBinaryOperator multiply = Functions::multiply;
    IO.println("multiply.applyAsInt(2, 3)=" + multiply.applyAsInt(2, 3));

    // 3 - Consumer<T>: un parámetro, sin resultado
    Consumer<String> write = IO::println;
    write.accept("Consumer<String> executed IO.println");

    // 4 - Predicate<T>: un parámetro, un resultado booleano
    Predicate<Integer> isEven = Functions::isEven;
    IO.println("isEven.test(8)=" + isEven.test(8));
    List<Integer> numbers = new ArrayList<>(List.of(3, 8, 1, 6, 5, 4));
    // removeIf de Collection espera un Predicate
    boolean modified = numbers.removeIf(isEven);
    IO.println("even numbers removed: " + modified + ", remaining: " + numbers);

    // 5 - Comparator<T>: dos parámetros T, un resultado int
    List<String> names = new ArrayList<>(List.of("Paul", "Mélanie", "Jo", "Sébastien"));
    names.sort(Functions::compareLengths);
    IO.println("sorted by length: " + names);

    // 6 - una lambda es un objeto: la instancia de una clase generada que implementa la interfaz
    IO.println("class: " + operation.getClass().getName());
    IO.println("interfaces: " + Arrays.toString(operation.getClass().getInterfaces()));
}

// los métodos referenciados, agrupados en una clase
// (la clase implícita de un archivo fuente compacto no puede nombrarse)
class Functions {

    static void display() {
        IO.println("display() executed by Runnable.run()");
    }

    static int add(int n1, int n2) {
        return n1 + n2;
    }

    static int multiply(int n1, int n2) {
        return n1 * n2;
    }

    static String greet() {
        return "Hello";
    }

    static boolean isEven(int n) {
        return n % 2 == 0;
    }

    static int compareLengths(String s1, String s2) {
        return Integer.compare(s1.length(), s2.length());
    }
}

Resultados:

> java Lambdas01.java
display() executed by Runnable.run()
operation.apply(2, 3)=5
greet.get()=Hello
multiply.applyAsInt(2, 3)=6
Consumer<String> executed IO.println
isEven.test(8)=true
even numbers removed: true, remaining: [3, 1, 5]
sorted by length: [Jo, Paul, Mélanie, Sébastien]
class: Lambdas01$$Lambda/0x0000000020165a28
interfaces: [interface java.util.function.BiFunction]

Comentarios:

  • líneas 5–10: creación de un objeto [Runnable] mediante una clase anónima, es decir, una clase sin nombre, declarada e instanciada justo donde se necesita. Implementa el método [run], que llama al método [display] de la línea 52. Esta era la sintaxis obligatoria antes de Java 8;
  • línea 12: lo mismo mediante una referencia a método: [Functions::display] hace referencia al método estático [display] de la clase [Functions]. El compilador verifica que tenga la forma del método [run] (sin parámetros y sin valor de retorno) y crea el objeto [Runnable] que lo llama. Esta es la sintaxis estándar hoy en día;
  • línea 14: la función se ejecuta llamando al método de la interfaz. Se ejecuta el método [display] de la línea 52 (línea 2 de los resultados);
  • líneas 48–50: los métodos referenciados se agrupan en una clase llamada [Functions]. Nos habría gustado escribirlos directamente en el archivo, junto a [main], y nombrarlos [Lambdas01::add]. Sin embargo, la clase implícita que envuelve un archivo fuente compacto no puede nombrarse en el código (el compilador devuelve [cannot find symbol]);
  • línea 17: [BiFunction<Integer, Integer, Integer>] hace referencia a una función con dos parámetros [Integer] que devuelve un [Integer] (el último tipo genérico). El método [add] de la línea 56, que trabaja con [int], es adecuado: el compilador agrega las conversiones entre [int] e [Integer]. La función se llama mediante su método [apply] (línea 18);
  • línea 20: [Supplier<String>] hace referencia a una función sin parámetros que devuelve una cadena de caracteres. Se llama mediante su método [get];
  • línea 23: la versión primitiva [IntBinaryOperator] opera directamente sobre valores [int], sin conversión. Su método se llama [applyAsInt]. Es el tipo preferido para tareas de cálculo intensivo;
  • línea 27: [Consumer<String>] hace referencia a una función que recibe un parámetro [String] y no devuelve nada. El método estático [IO.println(Object)] es adecuado: un [String] es un [Object]. Se ejecuta mediante su método [accept];
  • línea 31: un predicado es una función que devuelve un valor booleano; se ejecuta mediante su método [test] (línea 32). El método [removeIf] de la interfaz [Collection] (línea 35) espera un parámetro de tipo [Predicate]: elimina de la colección todos los elementos para los que el predicado devuelve [true], y devuelve [true] si eliminó al menos un elemento;
  • línea 40: el método [sort] de la interfaz [List] acepta un [Comparator] que compara dos elementos (el resultado puede ser negativo, cero o positivo, como [compareTo]). Aquí, los nombres se ordenan de forma ascendente según su longitud. El método [compareLengths] (línea 72) usa [Integer.compare], que compara dos objetos [int] sin riesgo de desbordamiento (que una simple resta no garantiza);
  • líneas 44–45: una referencia a método, al igual que una lambda, es un objeto. Su clase, que se muestra en la línea 10 de los resultados, es una clase generada en tiempo de ejecución por la máquina virtual, cuyo nombre contiene [$$Lambda] seguido de una dirección que cambia de una ejecución a otra. En la línea 11 de los resultados vemos que esta clase implementa la interfaz [BiFunction]. Por lo tanto, una lambda no es un nuevo tipo de objeto: es una instancia de una clase ordinaria que implementa una interfaz funcional.

7.2. Definición de interfaces funcionales propias

Las interfaces predefinidas suelen ser suficientes, pero usted puede definir las suyas. Basta con escribir una interfaz con un único método abstracto, por ejemplo:

  • [interface Operation { int calculate(int n1, int n2); }]

Esta interfaz representa una función que recibe dos enteros y devuelve un entero. En comparación con [IntBinaryOperator]*, el tipo *[Operation] tiene un nombre que describe su propósito, su método tiene un nombre descriptivo ([calculate] en lugar de [applyAsInt]*), y sus parámetros tienen nombres ([n1], [n2]) que las herramientas de desarrollo muestran. Va precedida de la anotación [@FunctionalInterface]*: no es obligatoria, pero indica al compilador que verifique que la interfaz sea funcional y documenta la intención del desarrollador.

Una variable [op] de tipo [Operation] hace referencia a una sola función a la vez. A diferencia de otros lenguajes, que ofrecen “delegados de multidifusión”, Java no ofrece una forma de almacenar varias funciones en una sola variable y ejecutarlas todas con una sola llamada: cuando es necesario, las funciones se colocan en una lista y se ejecutan una por una. Esto es exactamente lo que haremos con los listeners de eventos.

Consideremos el ejemplo [Lambdas02.java]:

// definir sus propias interfaces funcionales

void main() {
    // una variable de tipo Operation recibe el método estático increase
    Operation op = Calculations::increase;
    // ejecutamos la operación
    int n = op.calculate(4, 7);
    IO.println("n=" + n);

    // creación de un objeto c1 de tipo Calculations
    var c1 = new Calculations();
    // almacenamos en op el método add del objeto c1
    op = c1::add;
    n = op.calculate(2, 3);
    IO.println("n=" + n);
    // luego el método subtract de c1
    op = c1::subtract;
    n = op.calculate(2, 3);
    IO.println("n=" + n);

    // una variable referencia una sola función: para ejecutar varias, se usa una lista
    List<Operation> operations = new ArrayList<>();
    operations.add(c1::add);
    operations.add(c1::subtract);
    operations.add((n1, n2) -> n1 * n2);
    for (Operation operation : operations) {
        IO.println("-> " + operation.calculate(10, 4));
    }

    // un método default de la interfaz construye una nueva operación
    Operation squaredSum = ((Operation) c1::add).then(x -> x * x);
    IO.println("squaredSum.calculate(1, 2)=" + squaredSum.calculate(1, 2));

    // Operation e IntBinaryOperator tienen la misma forma pero son dos tipos diferentes
    IntBinaryOperator other = op::calculate;
    IO.println("other.applyAsInt(5, 1)=" + other.applyAsInt(5, 1));

    // una interfaz funcional genérica
    Transformation<String, Integer> length = String::length;
    Transformation<Integer, String> stars = "*"::repeat;
    IO.println("length(\"Hello\")=" + length.transform("Hello"));
    IO.println("stars(5)=" + stars.transform(5));
}

// definición de una interfaz funcional: un solo método abstracto
// que acepta dos enteros como parámetros y devuelve un entero
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);

    // un método default no cuenta: la interfaz sigue siendo funcional
    default Operation then(IntUnaryOperator next) {
        return (n1, n2) -> next.applyAsInt(calculate(n1, n2));
    }
}

// una interfaz funcional genérica: T -> R
@FunctionalInterface
interface Transformation<T, R> {
    R transform(T value);
}

// una clase cuyos métodos tienen la forma de la interfaz Operation
class Calculations {
    // dos métodos de instancia
    int add(int n1, int n2) {
        IO.println("add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }

    int subtract(int n1, int n2) {
        IO.println("subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }

    // un método estático
    static int increase(int n1, int n2) {
        IO.println("increase(" + n1 + "," + n2 + ")");
        return n1 + 2 * n2;
    }
}

Resultados:

> java Lambdas02.java
increase(4,7)
n=18
add(2,3)
n=5
subtract(2,3)
n=-1
add(10,4)
-> 14
subtract(10,4)
-> 6
-> 40
add(1,2)
squaredSum.calculate(1, 2)=9
subtract(5,1)
other.applyAsInt(5, 1)=4
length("Hello")=5
stars(5)=*****

Comentarios:

  • líneas 47–55: definición de la interfaz funcional [Operation]. En un archivo fuente compacto, las declaraciones de tipos (clases, interfaces, records, etc.) pueden colocarse antes o después del método [main]; nosotros las colocamos después;
  • líneas 52–54: una interfaz funcional puede tener métodos [default]. El método [then] construye una nueva [Operation]: este método ejecuta la operación actual y luego aplica la función [next] a su resultado. Devuelve una lambda, que examinaremos en la siguiente sección. Los métodos de composición de las interfaces predefinidas ([andThen], [compose]…, etc.) están escritos según este modelo, del que hablaremos más adelante;
  • líneas 64–81: la clase [Calculations] tiene dos métodos de instancia, [add] y [subtract], y un método estático, [increase], los tres con la misma forma que el método [calculate];
  • línea 5: la variable [op] es de tipo [Operation]. Se le asigna una referencia al método estático [Calculations.increase];
  • línea 7: la operación se ejecuta mediante el método [calculate]. Se ejecuta el método [Calculations.increase] con los parámetros pasados a [calculate];
  • línea 11: se crea una instancia [c1] de la clase [Calculations] ;
  • línea 13: la referencia [c1::add] hace referencia al método [add] del objeto [c1]. [increase] era un método estático, mientras que [add] es un método de instancia: esto no marca ninguna diferencia. En el segundo caso, el objeto creado por el compilador también almacena el objeto [c1] sobre el cual se llamará al método;
  • línea 17: se hace lo mismo con el método de instancia [subtract];
  • líneas 22–28: para ejecutar varias operaciones, se colocan en una lista [List<Operation>], que luego se recorre. Se pueden mezclar referencias a métodos y lambdas (línea 25). Se obtiene cada resultado (líneas 8–12 de los resultados);
  • línea 31: el método [default] [then] se aplica a la operación [c1::add]. La conversión [(Operation)] es necesaria: una referencia a método no tiene un tipo propio, y no se puede llamar a un método sobre ella hasta que el compilador sepa qué interfaz implementa (volveremos sobre esto). [squaredSum.calculate(1, 2)] calcula (1+2)², que es 9 (líneas 13–14 de los resultados);
  • línea 35: [Operation] e [IntBinaryOperator] tienen exactamente la misma forma, pero son dos tipos diferentes sin relación de herencia. La asignación [IntBinaryOperator other = op;] sería rechazada ([incompatible types: Operation cannot be converted to IntBinaryOperator]). En cambio, la referencia a método [op::calculate] tiene la forma correcta: crea un [IntBinaryOperator] que llama al método [calculate] del objeto [op] ([c1::subtract] en este punto del programa);
  • líneas 57–61: una interfaz funcional puede ser genérica. [Transformation<T, R>] representa una función que recibe un [T] y devuelve un [R]: esto equivale a [Function<T, R>], con nombres elegidos por nosotros;
  • línea 39: [String::length] es adecuada para una [Transformation<String, Integer>]: el método [length] se llamará sobre la cadena pasada como parámetro. Línea 40: ["*"::repeat] hace referencia al método [repeat(int)] del objeto de tipo cadena ["*"]; recibe un entero y devuelve una cadena. Se trata de dos tipos diferentes de referencias a métodos, que analizaremos en detalle en la sección siguiente.

La anotación [@FunctionalInterface] entra en juego si se agrega accidentalmente un segundo método abstracto —por ejemplo, [int invert(int n);]— a la interfaz [Operation]. El compilador señala entonces la propia anotación y cada una de las lambdas y referencias a métodos que usan la interfaz (salida abreviada):

> java Lambdas02.java
Lambdas02.java:5: error: incompatible types: Operation is not a functional interface
    Operation op = Calculations::increase;
                   ^
    multiple non-overriding abstract methods found in interface Operation
...
Lambdas02.java:47: error: Unexpected @FunctionalInterface annotation
@FunctionalInterface
^
  Operation is not a functional interface
    multiple non-overriding abstract methods found in interface Operation
9 errors
error: compilation failed

Los mensajes del compilador [javac] están en inglés: el JDK no ofrece una traducción al español.

7.3. Clases anónimas, expresiones lambda y referencias a métodos

7.3.1. De las clases anónimas a las lambdas

En los ejemplos anteriores, cada función es un método con nombre escrito en otra parte del programa. Para funciones cortas que se usan una sola vez, esto resulta engorroso. Hasta Java 7, la única alternativa era la clase anónima: la clase que implementa la interfaz se escribe justo donde se crea el objeto. Java 8 introdujo una sintaxis mucho más concisa —las expresiones lambda—, que han reemplazado prácticamente a las clases anónimas para las interfaces funcionales. El programa [Lambdas03.java] muestra las diferentes formas:

// de clases anónimas a expresiones lambda

void main() {
    // 1 - una clase anónima: la clase que implementa la interfaz se escribe en el lugar
    IntBinaryOperator add = new IntBinaryOperator() {
        @Override
        public int applyAsInt(int n1, int n2) {
            return n1 + n2;
        }
    };
    IO.println("anonymous class: add(2, 3)=" + add.applyAsInt(2, 3));

    // 2 - lo mismo con una expresión lambda (Java 8): parámetros -> cuerpo
    IntBinaryOperator subtract = (int n1, int n2) -> {
        return n1 - n2;
    };
    IO.println("block-body lambda: subtract(2, 3)=" + subtract.applyAsInt(2, 3));

    // 3 - los tipos de los parámetros se infieren de la interfaz de destino
    IntBinaryOperator multiply = (n1, n2) -> n1 * n2;
    IO.println("expression-body lambda: multiply(2, 3)=" + multiply.applyAsInt(2, 3));

    // 4 - un solo parámetro: los paréntesis son opcionales
    IntUnaryOperator square = x -> x * x;
    Predicate<String> isEmpty = s -> s.isEmpty();
    IO.println("square(7)=" + square.applyAsInt(7) + ", isEmpty(\"\")=" + isEmpty.test(""));

    // 5 - sin parámetros: paréntesis vacíos
    Supplier<String> greet = () -> "Hello";
    Runnable beep = () -> IO.println("beep!");
    IO.println(greet.get());
    beep.run();

    // 6 - un cuerpo en bloque con varias instrucciones
    BiConsumer<String, Integer> repeat = (text, times) -> {
        for (int i = 0; i < times; i++) {
            IO.print(text);
        }
        IO.println();
    };
    repeat.accept("ab", 3);

    // 7 - parámetros sin nombre (Java 22): no necesitamos sus valores
    BiConsumer<Object, String> listener = (_, _) -> IO.println("event received");
    listener.accept(null, "click");

    // 8 - una lambda pasada directamente como parámetro de un método
    List<Integer> numbers = new ArrayList<>(List.of(3, 8, 1, 6, 5, 4));
    List<Integer> evens = new ArrayList<>(numbers);
    evens.removeIf(n -> n % 2 != 0);
    IO.println("evens: " + evens);
    numbers.sort((n1, n2) -> Integer.compare(n2, n1));
    IO.println("descending order: " + numbers);
}

Resultados:

> java Lambdas03.java
anonymous class: add(2, 3)=5
block-body lambda: subtract(2, 3)=-1
expression-body lambda: multiply(2, 3)=6
square(7)=49, isEmpty("")=true
Hello
beep!
ababab
event received
evens: [8, 6, 4]
descending order: [8, 6, 5, 4, 3, 1]

Comentarios:

  • líneas 5–10: una clase anónima. El operador [new] va seguido del nombre de la interfaz, paréntesis vacíos y el cuerpo de una clase que implementa la interfaz. El compilador genera una clase (con un nombre de su elección, [Lambdas03$1]) y crea una instancia de ella. Seis líneas para expresar [n1 + n2];
  • líneas 14–16: lo mismo mediante una expresión lambda. Escribimos la lista de parámetros, el operador [->] (una flecha, que se lee “da”), y luego el cuerpo. El nombre de la interfaz y el nombre del método han desaparecido: el compilador los conoce por el tipo de la variable, que se denomina el tipo de destino de la lambda. Una lambda cuyo cuerpo es un bloque delimitado por llaves es una lambda con cuerpo de bloque;
  • línea 20: los tipos de los parámetros han desaparecido. El compilador los infiere a partir del tipo de destino [IntBinaryOperator]: [n1] y [n2] son de tipo [int]. El cuerpo se reduce a una expresión, cuyo valor es el resultado de la lambda: se trata de una lambda con cuerpo de expresión. Es la forma más común;
  • línea 24: con un solo parámetro cuyo tipo no se especifica, los paréntesis son opcionales. [x -> x * x] se lee “x da x por x”. Línea 25: una lambda con un parámetro de tipo [String] que devuelve un valor booleano: es un [Predicate<String>];
  • líneas 29–30: sin parámetros, se usan paréntesis vacíos. Una lambda cuyo cuerpo es una llamada a un método de tipo [void] es adecuada para un [Runnable];
  • líneas 35–40: una lambda con cuerpo de bloque puede contener cualquier instrucción: declaraciones, bucles, condicionales, etc.;
  • línea 44: el carácter de guion bajo [_] designa un parámetro anónimo (Java 22). Se usa cuando la firma de la interfaz exige parámetros que la lambda no necesita, lo cual es habitual en los listeners de eventos. Se pueden incluir varios de estos parámetros en la misma lambda;
  • líneas 49–51: el uso más común de las lambdas es pasarlas directamente como parámetros a un método que espera una interfaz funcional. Compare con [Lambdas01.java]: ya no es necesario escribir un método [isEven]. Aquí trabajamos sobre una copia de la lista, porque [removeIf] modifica la lista sobre la que opera;
  • línea 52: una lambda de tipo [Comparator<Integer>] que invierte la comparación habitual: la lista se ordena de forma descendente.

Repasemos las formas de una expresión lambda:

Forma
Ejemplo
parámetros con tipo, cuerpo de bloque
[(int a, int b) -> { return a + b; }]
parámetros sin tipo, cuerpo de expresión
[(a, b) -> a + b]
un único parámetro sin tipo
[x -> x * x]
sin parámetros
[() -> "Hello"]
parámetros anónimos
[(_, _) -> IO.println("received")]
Parámetros declarados con [var]
[(var a, var b) -> a + b]

Los parámetros son todos con tipo o todos sin tipo: no se pueden mezclar ambos. En un cuerpo de bloque, una lambda que devuelve un resultado debe tener una instrucción [return] en cada ruta de ejecución, igual que un método.

Una lambda no es exactamente lo mismo que una clase anónima abreviada. En una clase anónima, [this] hace referencia a la instancia de la clase anónima; en una lambda, [this] hace referencia al objeto del método que contiene la lambda. Además, una clase anónima crea un nuevo ámbito: puede declarar una variable con el mismo nombre que una variable del método, lo que una lambda no puede hacer. Por último, una clase anónima puede implementar una interfaz con varios métodos o heredar de una clase abstracta, lo que es imposible con una lambda. En este curso usaremos lambdas siempre que sea posible.

7.3.2. Información adicional: tipo de destino y referencias a métodos

El programa [Lambdas04.java] define el concepto de tipo de destino y presenta los cuatro tipos de referencias a métodos:

// más sobre lambdas y referencias a métodos

void main() throws Exception {
    // 1 - una lambda no tiene tipo por sí misma: el contexto lo determina
    // var twice = x -> x * 2;  // rechazado: la lambda necesita un tipo de destino
    var twice = (IntUnaryOperator) x -> x * 2;
    IO.println("twice(21)=" + twice.applyAsInt(21));
    // el mismo texto de lambda puede implementar dos interfaces diferentes
    Supplier<String> supplier = () -> "Hello";
    Callable<String> callable = () -> "Hello";
    IO.println(supplier.get() + " / " + callable.call());

    // 2 - parámetros declarados con var (Java 11): permite anotarlos o hacerlos final
    BinaryOperator<String> concatenate = (final var s1, final var s2) -> s1 + s2;
    IO.println(concatenate.apply("lam", "bda"));

    // 3 - los cuatro tipos de referencias a métodos
    // a) método estático: Class::staticMethod
    Function<String, Integer> convert = Integer::parseInt;
    IO.println("convert(\"42\") + 1 = " + (convert.apply("42") + 1));
    // b) método de instancia de un objeto dado: object::method
    String name = "Pierre";
    Supplier<String> inUpperCase = name::toUpperCase;
    IO.println("inUpperCase.get()=" + inUpperCase.get());
    // c) método de instancia de un objeto arbitrario: Class::instanceMethod
    //    el objeto sobre el que se llama el método pasa a ser el primer parámetro
    UnaryOperator<String> upperCase = String::toUpperCase;
    Comparator<String> ignoreCase = String::compareToIgnoreCase;
    IO.println("upperCase(\"paul\")=" + upperCase.apply("paul")
            + ", ignoreCase(\"abc\", \"ABC\")=" + ignoreCase.compare("abc", "ABC"));
    // d) constructor: Class::new
    Supplier<List<String>> createList = ArrayList::new;
    Function<String, StringBuilder> createBuffer = StringBuilder::new;
    IntFunction<int[]> createArray = int[]::new;
    List<String> list = createList.get();
    list.add("element");
    IO.println(list + " " + createBuffer.apply("abc").reverse() + " " + createArray.apply(3).length);

    // 4 - excepciones verificadas: Callable.call puede lanzarlas, Supplier.get no
    Callable<Integer> read = () -> {
        throw new IOException("missing file");
    };
    try {
        read.call();
    } catch (IOException ex) {
        IO.println("exception received: " + ex.getMessage());
    }

    // 5 - cada evaluación de una lambda o de una referencia a método puede crear un nuevo objeto
    Supplier<String> r1 = name::toUpperCase;
    Supplier<String> r2 = name::toUpperCase;
    IO.println("r1 == r2: " + (r1 == r2) + ", r1.equals(r2): " + r1.equals(r2));
}

Resultados:

> java Lambdas04.java
twice(21)=42
Hello / Hello
lambda
convert("42") + 1 = 43
inUpperCase.get()=PIERRE
upperCase("paul")=PAUL, ignoreCase("abc", "ABC")=0
[element] cba 3
exception received: missing file
r1 == r2: false, r1.equals(r2): false

Comentarios:

  • línea 5: una lambda no tiene un tipo propio. Su tipo lo determina el contexto: el tipo de la variable que la recibe, el tipo del parámetro al que se pasa o el tipo especificado por una conversión. Por lo tanto, el compilador rechaza la declaración [var twice = x -> x * 2;]: [cannot infer type for local variable twice (lambda expression needs an explicit target-type)]. No sabría qué interfaz implementar;
  • línea 6: con una conversión a [IntUnaryOperator], el tipo de destino es conocido, y [var] pasa a ser válido. En la práctica, se escribiría en cambio [IntUnaryOperator twice = x -> x * 2;];
  • líneas 9–10: la misma expresión lambda, [() -> "Hello"], implementa aquí un [Supplier<String>] y allá un [Callable<String>]. Son dos objetos de clases diferentes, que solo comparten la forma de su método;
  • línea 14: desde Java 11, los parámetros de las lambdas pueden declararse con [var], lo que permite agregarles un modificador ([final]) o una anotación, algo que no es posible con un parámetro sin tipo;
  • líneas 17–37: los cuatro tipos de referencias a métodos:
    • línea 19: una referencia a un método estático, [Class::staticMethod]. [Integer::parseInt] equivale a la lambda [s -> Integer.parseInt(s)];
    • línea 23: una referencia a un método de instancia de un objeto determinado, [object::method]. [name::toUpperCase] equivale a [() -> name.toUpperCase()]: el objeto [name] queda fijado de una vez por todas;
    • líneas 27–28: una referencia a un método de instancia de cualquier objeto de una clase, [Class::instanceMethod]. El objeto sobre el que se llamará al método aún no se conoce: se convierte en el primer parámetro de la función. [String::toUpperCase] equivale a [s -> s.toUpperCase()] (un parámetro), y [String::compareToIgnoreCase] equivale a [(s1, s2) -> s1.compareToIgnoreCase(s2)] (dos parámetros), de ahí [Comparator<String>];
    • líneas 32–34: la referencia a un constructor, [Class::new]. [ArrayList::new] equivale a [() -> new ArrayList<>()]; [StringBuilder::new], con un tipo de destino de [Function<String, StringBuilder>], selecciona el constructor que recibe una cadena; [int[]::new] crea un arreglo del tamaño pasado como parámetro;
  • línea 37: se usan las tres funciones de creación; [reverse] invierte el contenido de [StringBuilder] (línea 8 de los resultados);
  • líneas 40–47: una diferencia significativa entre [Callable] y [Supplier]. El método [call] se declara como [throws Exception]: por lo tanto, una lambda de tipo [Callable] puede lanzar una excepción verificada (véase el capítulo 3), en este caso una [IOException]. El método [get] de [Supplier] no declara ninguna excepción: la misma lambda de tipo [Supplier<Integer>] sería rechazada ([unreported exception IOException; must be caught or declared to be thrown]). Ninguna interfaz de tipo [java.util.function] permite excepciones verificadas: una lambda que lanza una debe capturarla ella misma o usar una interfaz cuyo método la declare. Por eso [main] se declara como [throws Exception] (línea 3): las llamadas a [callable.call()] (línea 11) y [read.call()] (línea 44) podrían teóricamente lanzar cualquier [Exception], que el [catch] de la línea 45 —limitado a [IOException]— no intercepta;
  • líneas 50–52: dos evaluaciones de la misma referencia a método [name::toUpperCase] producen dos objetos diferentes, que ni [==] ni [equals] consideran iguales (línea 10 de los resultados). Tenga presente esto: será importante al cancelar la suscripción a un listener de eventos.

Una referencia a método es simplemente una notación abreviada para una lambda que solo llama a un método. La usamos cuando mejora la legibilidad: [String::length] en lugar de [s -> s.length()].

7.3.3. Composición de funciones

Las interfaces funcionales predefinidas tienen métodos [default] y [static] que crean nuevas funciones a partir de las existentes, como el método [then] de nuestra interfaz [Operation]. El programa [Lambdas05.java] enumera los principales:

// composición de funciones: andThen, compose, and, or, negate, comparing, thenComparing

void main() {
    // 1 - Function: andThen (primero esta, luego la otra) y compose (primero la otra)
    Function<Integer, Integer> plusOne = x -> x + 1;
    Function<Integer, Integer> timesTwo = x -> x * 2;
    IO.println("plusOne.andThen(timesTwo).apply(5)=" + plusOne.andThen(timesTwo).apply(5));
    IO.println("plusOne.compose(timesTwo).apply(5)=" + plusOne.compose(timesTwo).apply(5));
    // una cadena de procesamiento construida a partir de una lista de funciones
    List<UnaryOperator<String>> steps =
            List.of(String::strip, String::toLowerCase, s -> s.replace(' ', '-'));
    Function<String, String> normalize = Function.identity();
    for (UnaryOperator<String> step : steps) {
        normalize = normalize.andThen(step);
    }
    IO.println("normalize(\"  My Nice Title \")=" + normalize.apply("  My Nice Title "));

    // 2 - Predicate: and, or, negate, Predicate.not
    Predicate<String> isShort = s -> s.length() <= 4;
    Predicate<String> startsWithP = s -> s.startsWith("P");
    List<String> firstNames = List.of("Paul", "Mélanie", "Jo", "Sébastien", "Pierre");
    IO.println("short and P: " + filter(firstNames, isShort.and(startsWithP)));
    IO.println("short or P: " + filter(firstNames, isShort.or(startsWithP)));
    IO.println("not short: " + filter(firstNames, isShort.negate()));
    IO.println("not empty: " + filter(List.of("a", "", "b"), Predicate.not(String::isEmpty)));

    // 3 - Consumer: andThen encadena dos procesamientos sobre el mismo valor
    List<String> log = new ArrayList<>();
    Consumer<String> display = s -> IO.println("display: " + s);
    Consumer<String> remember = log::add;
    Consumer<String> both = display.andThen(remember);
    both.accept("first");
    both.accept("second");
    IO.println("log: " + log);

    // 4 - Comparator: comparing, thenComparing, reversed
    List<Person> persons = new ArrayList<>(List.of(new Person("Paul", 32),
            new Person("Mélanie", 25), new Person("Jo", 32), new Person("Sébastien", 25)));
    persons.sort(Comparator.comparing(Person::age).thenComparing(Person::name));
    IO.println("by age then name: " + persons);
    persons.sort(Comparator.comparingInt(Person::age).reversed()
            .thenComparing(Person::name, Comparator.reverseOrder()));
    IO.println("by descending age then descending name: " + persons);
    // BinaryOperator.minBy construye una función a partir de un comparador
    BinaryOperator<Person> youngest = BinaryOperator.minBy(Comparator.comparingInt(Person::age));
    IO.println("youngest(Paul, Mélanie)=" + youngest.apply(persons.get(0), persons.get(3)));
}

// conserva los elementos que cumplen el predicado
static <T> List<T> filter(List<T> elements, Predicate<? super T> predicate) {
    List<T> result = new ArrayList<>();
    for (T element : elements) {
        if (predicate.test(element)) {
            result.add(element);
        }
    }
    return result;
}

record Person(String name, int age) {
    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

Resultados:

> java Lambdas05.java
plusOne.andThen(timesTwo).apply(5)=12
plusOne.compose(timesTwo).apply(5)=11
normalize("  My Nice Title ")=my-nice-title
short and P: [Paul]
short or P: [Paul, Jo, Pierre]
not short: [Mélanie, Sébastien, Pierre]
not empty: [a, b]
display: first
display: second
log: [first, second]
by age then name: [Mélanie(25), Sébastien(25), Jo(32), Paul(32)]
by descending age then descending name: [Paul(32), Jo(32), Sébastien(25), Mélanie(25)]
youngest(Paul, Mélanie)=Mélanie(25)

Comentarios:

  • línea 7: [f.andThen(g)] devuelve el resultado de aplicar primero [f] y luego [g]: (5 + 1) × 2 = 12;
  • línea 8: [f.compose(g)] aplica primero [g] y luego [f]: 5 × 2 + 1 = 11;
  • líneas 10–15: una cadena de procesamiento construida dinámicamente. Partimos de la función identidad ([Function.identity()], que deja su parámetro sin cambios) y agregamos, mediante [andThen], cada paso de la lista. La función resultante [normalize] elimina los espacios iniciales y finales, convierte el texto a minúsculas y reemplaza los espacios por guiones. Cada llamada a [andThen] crea una función nueva: las funciones existentes nunca se modifican. De igual manera, la lista de pasos podría leerse de un archivo de configuración;
  • líneas 19–25: los predicados se combinan mediante [and] (y), [or] (o) y [negate] (no). El método estático [Predicate.not] (Java 11) devuelve la negación de un predicado: permite escribir [Predicate.not(String::isEmpty)], mientras que [String::isEmpty.negate()] es rechazado (una referencia a método no tiene tipo hasta que tiene un tipo de destino);
  • líneas 28–34: [c1.andThen(c2)] devuelve un [Consumer], que ejecuta [c1] y luego [c2] sobre el mismo valor. Esta es la manera más sencilla en Java de ejecutar varias operaciones con una sola llamada. Línea 30: [log::add] es una referencia al método [add] del objeto [log];
  • línea 39: [Comparator.comparing(f)] construye un comparador que compara los valores de [f] (aquí, la edad); [thenComparing] especifica el criterio de desempate que se usará en caso de empate (aquí, el nombre). El record [Person] (líneas 60–65) proporciona los accesores [age()] y [name()]; hemos redefinido su método [toString] para acortar la salida mostrada;
  • líneas 41–42: [comparingInt] evita convertir la edad a [Integer], [reversed] invierte el orden obtenido hasta ese momento, y la segunda forma de [thenComparing] recibe, además del criterio, el comparador que se usará para ese criterio: [Comparator.reverseOrder()], el orden natural invertido;
  • líneas 45–46: [BinaryOperator.minBy] convierte un comparador en una función que devuelve el menor de sus dos parámetros;
  • líneas 50–58: el método [filter] usado para estas pruebas. Su parámetro es de tipo [Predicate<? super T>] en lugar de [Predicate<T>]: por lo tanto, para filtrar una lista de [String], acepta un [Predicate<String>] así como un [Predicate<Object>] o un [Predicate<CharSequence>]. Esta es la regla que se sigue en toda la biblioteca de Java: un parámetro funcional que consume [T] se declara con [? super T], y un parámetro que produce valores T se declara con [? extends T].

Estos métodos permiten escribir procesos complejos combinando funciones simples, sin escribir una sola clase. Volveremos sobre ellos con la API Stream.

7.3.4. Captura de variables y closures

Una lambda puede usar las variables locales del método en el que se define. Se dice que captura esas variables. Java impone una regla importante al respecto, que distingue al lenguaje de muchos otros (C#, JavaScript, Python): una variable local capturada debe ser “efectivamente final”, es decir, no debe modificarse nunca después de su inicialización, ni en el método ni en la lambda. El programa [Lambdas06.java] muestra lo que esta regla permite y lo que prohíbe:

// captura de variables y clausuras

// un campo de la clase implícita: las lambdas pueden modificarlo
int nbCalls;

void main() {
    // 1 - una lambda puede usar las variables locales que la rodean...
    int threshold = 5;
    Predicate<Integer> exceeds = n -> n > threshold;
    IO.println("threshold=" + threshold + " : exceeds(7)=" + exceeds.test(7));
    // ... siempre que sean efectivamente final: threshold = 10; sería rechazado
    int otherThreshold = 10;
    Predicate<Integer> exceedsOther = n -> n > otherThreshold;
    IO.println("threshold=" + otherThreshold + " : exceeds(7)=" + exceedsOther.test(7));

    // 2 - una lambda no puede modificar una variable local capturada...
    // int total = 0; IntConsumer accumulate = n -> total += n;  // rechazado
    // ... pero sí puede modificar el objeto al que esta referencia
    AtomicInteger total = new AtomicInteger();
    IntConsumer accumulate = n -> total.addAndGet(n);
    accumulate.accept(3);
    accumulate.accept(4);
    IO.println("total=" + total.get());
    // ... o un campo del objeto actual (la lambda captura this)
    Runnable count = () -> nbCalls++;
    count.run();
    count.run();
    IO.println("nbCalls=" + nbCalls);

    // 3 - una clausura: el objeto capturado sobrevive al método que lo creó
    IntSupplier counterA = createCounter();
    IntSupplier counterB = createCounter();
    IO.println("A : " + counterA.getAsInt() + " " + counterA.getAsInt() + " " + counterA.getAsInt());
    IO.println("B : " + counterB.getAsInt() + " " + counterB.getAsInt());

    // 4 - el bucle for: la variable i cambia, no puede capturarse
    List<Runnable> actions = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        // actions.add(() -> IO.print(i + " "));  // rechazado: i no es efectivamente final
        int copy = i;
        actions.add(() -> IO.print(copy + " "));
    }
    IO.print("for, capture of a copy: ");
    actions.forEach(Runnable::run);
    IO.println();

    // el bucle for-each declara una nueva variable en cada iteración: es efectivamente final
    actions.clear();
    for (int j : new int[] { 0, 1, 2 }) {
        actions.add(() -> IO.print(j + " "));
    }
    IO.print("for-each: ");
    actions.forEach(Runnable::run);
    IO.println();
}

// un método que devuelve una función
static IntSupplier createCounter() {
    // objeto local capturado por la lambda devuelta
    AtomicInteger value = new AtomicInteger();
    return () -> value.incrementAndGet();
}

Resultados:

1
2
3
4
5
6
7
8
9
> java Lambdas06.java
threshold=5 : exceeds(7)=true
threshold=10 : exceeds(7)=false
total=7
nbCalls=2
A : 1 2 3
B : 1 2
for, capture of a copy: 0 1 2 
for-each: 0 1 2 

Comentarios:

  • línea 9: la lambda usa la variable local [threshold] declarada en la línea 8. [threshold] no es un parámetro de la lambda; es una variable capturada. La variable nunca se modifica: es efectivamente final, sin necesidad de declararla como [final] (lo cual era obligatorio hasta Java 7 para las clases anónimas);
  • línea 11: si agregáramos [threshold = 10;] después de crear la lambda, el compilador rechazaría la lambda de la línea 9: *[local variables referenced from a lambda expression must be final or effectively final]. Para cambiar el umbral, creamos otra variable y otra lambda (líneas 12–13). Por el contrario, la pregunta “¿la lambda ve el valor de la variable en el momento de su creación o su valor en el momento de su ejecución?” no se plantea en Java: ambos son idénticos. En concreto, la lambda recibe una copia* del valor de la variable cuando se crea;
  • línea 17: por la misma razón, una lambda no puede modificar una variable local capturada: [n -> total += n] es rechazada, con el mismo mensaje;
  • líneas 19–23: la variable capturada [total] no cambia; sigue haciendo referencia al mismo objeto, [AtomicInteger]. Sin embargo, nada impide que la lambda modifique el estado de este objeto. La clase [AtomicInteger] del paquete [java.util.concurrent.atomic] encapsula un entero mutable ([addAndGet], [incrementAndGet], [get]…), que puede usarse de forma segura desde varios hilos (capítulo 8). También encontramos la técnica del arreglo de un solo elemento ([int[] total = {0};] seguido de [total[0] += n]), que no tiene esta última propiedad;
  • líneas 4 y 25–28: la regla se aplica solo a las variables locales. Una lambda puede leer y modificar los campos del objeto actual: captura entonces la referencia [this], que a su vez no cambia. El campo [nbCalls] es un campo de la clase implícita del archivo fuente compacto; como el método [main] es un método de instancia, la lambda puede incrementarlo;
  • líneas 58–62: el método *[createCounter] devuelve una lambda que captura su variable local *[value]*. Normalmente, una variable local se destruye cuando termina el método. Aquí, la lambda devuelta ha conservado una copia de la referencia [value], y el objeto referenciado [AtomicInteger] sobrevive a [createCounter]* mientras exista la lambda. La combinación de la lambda y los valores que captura se denomina “closure”. Para crearla, la máquina virtual almacena los valores capturados en campos del objeto que crea para la lambda;
  • líneas 31–34: cada llamada a [createCounter] crea un nuevo objeto [AtomicInteger] —y, por lo tanto, un nuevo contador— independiente de los demás. Los resultados (líneas 6–7) lo confirman;
  • líneas 38–42: en un bucle [for] estándar, la variable [i] se modifica en cada iteración ([i++]): no es efectivamente final, y la lambda de la línea 39 sería rechazada. En otros lenguajes, esta captura está permitida y conduce a un resultado inesperado: las tres lambdas comparten la misma variable [i] y todas imprimen 3, su valor al final del bucle. Java elimina esta trampa en tiempo de compilación. La solución es declarar una variable [copy] dentro del cuerpo del bucle —una nueva en cada iteración que nunca se modifica (línea 40)— de modo que cada lambda capture la suya;
  • líneas 49–51: con el bucle “para cada elemento” [for], el problema no se presenta: la variable [j] es una variable nueva en cada iteración, nunca se modifica y, por lo tanto, es efectivamente final;
  • líneas 44 y 53: el método [forEach] de las colecciones espera un [Consumer] y lo ejecuta sobre cada elemento. Aquí, cada elemento es a su vez un *[Runnable]*, y la referencia **[Runnable::run]*** (cualquier objeto de tipo *[Runnable]*, sobre el cual se llama a *[run] ) lo ejecuta.

La regla sobre las variables efectivamente finales puede parecer restrictiva. Sin embargo, tiene una justificación sólida: una lambda puede ejecutarse más tarde o en otro hilo (capítulo 8). Si pudiera modificar las variables locales de un método que quizá ya terminó, o leerlas mientras otro hilo las modifica, nos encontraríamos con un comportamiento difícil de predecir. Al exigir que las variables permanezcan sin cambios, Java evita estas situaciones; cuando un estado compartido y mutable es realmente necesario, se hace explícito mediante un objeto ([AtomicInteger], colección…) cuyo comportamiento con respecto a los hilos está especificado.

7.4. ¿Interfaces funcionales o interfaces?

En muchos lenguajes, el concepto de «función pasada como parámetro» (puntero a función en C, delegado en C#) es distinto del concepto de interfaz, y uno podría preguntarse cuál elegir. En Java, la pregunta se plantea de otra manera, porque los dos conceptos son uno solo: una lambda es una instancia de una interfaz. Veamos el ejemplo [Lambdas07.java], que es similar a [Lambdas02.java]:

// un parámetro de un tipo de interfaz funcional

void main() {
    // ejecución del método add
    IO.println(execute(Methods::add, 2, 3));
    // ejecución del método subtract
    IO.println(execute(Methods::subtract, 2, 3));
    // ejecución de un método de la biblioteca de Java que tiene la forma adecuada
    IO.println(execute(Math::max, 2, 3));
    // ejecución de una lambda: no se necesita ningún método con nombre
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
}

// ejecución de una operación recibida como parámetro
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// dos métodos que tienen la forma de la interfaz Operation
class Methods {
    static int add(int n1, int n2) {
        IO.println("add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }

    static int subtract(int n1, int n2) {
        IO.println("subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }
}

// la interfaz funcional
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);
}

Resultados:

1
2
3
4
5
6
7
> java Lambdas07.java
add(2,3)
5
subtract(2,3)
-1
3
6

En la línea 15, el método *[execute] espera un parámetro del tipo definido por la interfaz funcional *[Operation] de la línea 34. Esto permite pasarle diferentes funciones: métodos estáticos de nuestra clase [Methods] (líneas 5 y 7), un método de la biblioteca de Java con la forma correcta (línea 9: entre las sobrecargas de *[Math.max]*, el compilador elige ***[int max(int a, int b)]*), e incluso una lambda (línea 11): no fue necesario escribir un método de multiplicación. Este polimorfismo es el de las interfaces, tratado en el capítulo 4: el programa [Lambdas08.java] lo demuestra implementando la misma interfaz con clases:

// clases que implementan la interfaz funcional

void main() {
    // ejecución de la operación Add
    IO.println(execute(new Add(), 2, 3));
    // ejecución de la operación Subtract
    IO.println(execute(new Subtract(), 2, 3));
    // el mismo método execute sigue aceptando lambdas
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
    // una interfaz con dos métodos abstractos ya no acepta una lambda: se necesita una clase
    NamedOperation division = new NamedOperation() {
        @Override
        public int calculate(int n1, int n2) {
            return n1 / n2;
        }

        @Override
        public String name() {
            return "integer division";
        }
    };
    IO.println(division.name() + " : " + division.calculate(7, 2));
}

// ejecución del único método de la interfaz Operation
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// interfaz Operation
interface Operation {
    int calculate(int n1, int n2);
}

// una interfaz que no es funcional: dos métodos abstractos
interface NamedOperation extends Operation {
    String name();
}

// clase Add
class Add implements Operation {
    @Override
    public int calculate(int n1, int n2) {
        IO.println("Add(" + n1 + "," + n2 + ")");
        return n1 + n2;
    }
}

// clase Subtract
class Subtract implements Operation {
    @Override
    public int calculate(int n1, int n2) {
        IO.println("Subtract(" + n1 + "," + n2 + ")");
        return n1 - n2;
    }
}

Resultados:

1
2
3
4
5
6
7
> java Lambdas08.java
Add(2,3)
5
Subtract(2,3)
-1
6
integer division : 3

Comentarios:

  • Líneas 31–33: La interfaz [Operation] define un método [calculate]. No está anotada con [@FunctionalInterface]: la anotación es solo una verificación, y cualquier interfaz con un único método abstracto es funcional;
  • líneas 41–47 y 50–56: las clases *[Add] y *[Subtract] implementan la interfaz *[Operation]*;
  • líneas 26–28: el método [execute], cuyo primer parámetro es del tipo de la interfaz [Operation]. Recibe, sucesivamente, una instancia de la clase [Add], una instancia de la clase [Subtract] (líneas 5 y 7) y luego una lambda (línea 9). Para [execute], estos tres objetos son del mismo tipo: objetos que implementan [Operation];
  • Líneas 36–38: La interfaz [NamedOperation] hereda el método [calculate] y agrega un método [name]. Con dos métodos abstractos, ya no es funcional: ya no puede implementarse mediante una lambda; se requiere una clase, en este caso una clase anónima (líneas 11–21).

Estos dos ejemplos muestran que en Java no hay que elegir entre dos mecanismos: un método que espera una interfaz de un solo método acepta objetos de clases escritas para la ocasión, referencias a métodos y lambdas por igual. La verdadera pregunta es entonces: ¿debe la interfaz ser funcional, con un único método, o debe tener varios métodos?

  • Una interfaz de un solo método, ya sea predefinida ([Function], [Predicate]…) o no, resulta más flexible de usar: sirve cualquier método existente con la forma correcta, y una lambda permite incluso escribir la función en el mismo punto de la llamada. No hay que escribir ninguna clase. Esta flexibilidad explica por qué las bibliotecas modernas (la API Stream, la programación asíncrona del capítulo 9, Spring) hacen un uso intensivo de las interfaces funcionales;
  • una interfaz con varios métodos recupera la ventaja en cuanto el comportamiento que se quiere implementar involucra varias operaciones interrelacionadas ([calculate] y [name] arriba), o cuando requiere su propio estado e identidad.

Este es el caso de la interfaz [ITaxDao] en la capa [dao] del capítulo 6: aunque tiene un solo método, [List<TaxBracket> getTaxBrackets()], sus implementaciones tienen estado (los tramos leídos, el nombre del archivo), son creadas por el contenedor de inyección de dependencias y representan un rol claramente nombrado dentro de la aplicación. Un [Supplier<List<TaxBracket>>] habría bastado técnicamente, pero habría sido mucho menos descriptivo. Por ello reservamos las interfaces funcionales para comportamientos breves y puntuales (un criterio, una transformación, una acción), y las interfaces «de negocio» para los roles de la aplicación, sin importar el número de métodos que contengan.

7.5. Manejo de eventos

7.5.1. El modelo de oyentes

Las interfaces funcionales se utilizan para configurar eventos. Java no tiene una palabra clave dedicada para los eventos: utiliza un conjunto de convenciones, conocido como el «modelo de oyentes» (listener model), establecido desde Java 1.1 para los componentes gráficos y los JavaBeans. Una clase [C1] que quiere señalar un evento [Xxx] procede de la siguiente manera:

  • Una clase [XxxEvent], derivada de [java.util.EventObject], encapsula la información del evento. [EventObject] almacena el objeto que desencadenó el evento, denominado origen (source), que se obtiene mediante [getSource()];
  • una interfaz [XxxListener], que extiende la interfaz vacía [java.util.EventListener] (un simple marcador), define el o los métodos que se llamarán cuando ocurra el evento. Con un solo método, es una interfaz funcional: un oyente puede ser una lambda;
  • La clase [C1] administra una lista de oyentes y ofrece dos métodos públicos para suscribirse a ella y cancelar la suscripción: [addXxxListener(XxxListener l)] y [removeXxxListener(XxxListener l)];
  • Cuando una instancia [c1] de [C1] quiere señalar el evento, crea un objeto [XxxEvent] y llama al método de cada oyente registrado, pasándole este objeto. Por convención, esta notificación la realiza un método protegido [fireXxx(XxxEvent e)] («fire», disparar), que una clase derivada puede redefinir para modificar la forma en que se publica el evento;
  • si un objeto [c2] quiere ser notificado del evento [Xxx] del objeto [c1], se registra mediante [c1.addXxxListener(...)]. Puede cancelar su suscripción mediante [c1.removeXxxListener(...)] cuando ya no desee ser notificado. Dado que [c1] administra una lista, distintos objetos pueden suscribirse para ser notificados del mismo evento.

En este esquema, tenemos:

  • una clase que señala (también se dice «publica» o «emite») un evento;
  • objetos que son notificados de este evento. Se dice que se suscriben o se registran al evento: son los oyentes, o manejadores de eventos;
  • una interfaz de oyente que define la firma de los métodos que serán notificados del evento.

Este es el patrón de diseño Observer: el emisor no conoce a sus suscriptores; simplemente los notifica. Este modelo ofrece la misma protección que una palabra clave dedicada: la lista de oyentes es un campo privado del emisor. Desde el exterior, solo se puede suscribir o cancelar la suscripción; no se puede vaciar la lista, reemplazar a otros oyentes ni desencadenar el evento en lugar del emisor.

7.5.2. Un ejemplo: temperatura excesivamente alta

Consideremos el siguiente ejemplo:

  • Una clase llamada [Emitter] encapsula una temperatura. Cuando esta temperatura supera cierto umbral, debe desencadenarse un evento. Llamaremos a este evento [TemperatureTooHigh]. La información sobre este evento se encapsulará en un objeto [TemperatureTooHighEvent], y los oyentes implementarán la interfaz [TemperatureTooHighListener];
  • una clase llamada [Subscriber] se registra como oyente del evento mencionado. Cuando se le notifica el evento, muestra un mensaje en la consola. Un suscriptor cancela su suscripción automáticamente tras recibir un número determinado de alertas;
  • Un programa de consola crea un emisor y dos suscriptores. Ingresa temperaturas por teclado y las almacena en el emisor. Si alguna es demasiado alta, el emisor señala el evento [TemperatureTooHigh].

Todas estas clases se agrupan en el archivo fuente compacto [Lambdas09.java], que presentamos en tres partes. Primero, aquí están la clase del evento, la interfaz del oyente y la clase [Emitter]:

// la información que transporta el evento
class TemperatureTooHighEvent extends EventObject {
    @Serial
    private static final long serialVersionUID = 1L;
    // temperatura en el momento del evento
    private final double temperature;
    // hora del evento
    private final LocalTime time = LocalTime.now();

    TemperatureTooHighEvent(Emitter source, double temperature) {
        super(source);
        this.temperature = temperature;
    }

    // la fuente es necesariamente un Emitter: redefinimos getSource con un tipo más preciso
    @Override
    public Emitter getSource() {
        return (Emitter) super.getSource();
    }

    double getTemperature() {
        return temperature;
    }

    LocalTime getTime() {
        return time;
    }
}

// la interfaz que deben implementar los oyentes del evento
@FunctionalInterface
interface TemperatureTooHighListener extends EventListener {
    void temperatureTooHigh(TemperatureTooHighEvent e);
}

// la clase que señala el evento
class Emitter {
    // umbral que desencadena el evento
    static final double THRESHOLD = 19;
    // nombre del emisor
    private final String name;
    // temperatura observada
    private double temperature;
    // los oyentes registrados
    private final List<TemperatureTooHighListener> listeners = new CopyOnWriteArrayList<>();

    Emitter(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    double getTemperature() {
        return temperature;
    }

    void setTemperature(double temperature) {
        this.temperature = temperature;
        if (temperature > THRESHOLD) {
            // se notifica el evento a los oyentes
            fireTemperatureTooHigh(new TemperatureTooHighEvent(this, temperature));
        }
    }

    // registro de un oyente
    void addTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.add(Objects.requireNonNull(listener));
    }

    // baja de un oyente
    void removeTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.remove(listener);
    }

    // notificación del evento a todos los oyentes registrados
    protected void fireTemperatureTooHigh(TemperatureTooHighEvent e) {
        for (TemperatureTooHighListener listener : listeners) {
            listener.temperatureTooHigh(e);
        }
    }
}

Comentarios:

  • líneas 1–28: La clase [TemperatureTooHighEvent] deriva de [EventObject], según la convención. Su constructor (líneas 10–13) pasa el origen del evento al constructor de [EventObject] ([super(source)]) y almacena la temperatura que desencadenó el evento. Hemos agregado la hora del evento, [time] (línea 8). Los campos son [final], y la clase solo tiene accesores de solo lectura: un oyente no debe poder modificar la información del evento para los oyentes siguientes;
  • líneas 3–4: [EventObject] implementa la interfaz [Serializable] (para que los eventos puedan registrarse o transmitirse por una red). El compilador, al usar la opción [-Xlint:all], exige entonces que cada clase derivada declare un número de versión [serialVersionUID]. La anotación [@Serial] (Java 14) señala al compilador este campo específico;
  • líneas 16–19: El método [getSource] de [EventObject] devuelve un [Object]. Lo redefinimos con un tipo de retorno más específico, [Emitter], lo que Java permite (tipo de retorno covariante): los oyentes no tendrán que convertir el origen. No podemos usar un *[record]* aquí: un record no puede heredar de ninguna clase y, por lo tanto, no puede heredar de *[EventObject]*;
  • Líneas 30–34: la interfaz del oyente. Extiende [EventListener] y declara un único método, [temperatureTooHigh], que recibe el objeto del evento: se trata de una interfaz funcional;
  • línea 39: el umbral de temperatura por encima del cual se desencadena el evento [TemperatureTooHigh];
  • línea 41: el emisor tiene un nombre para su identificación;
  • línea 45: la lista de oyentes registrados. Es una [CopyOnWriteArrayList] del paquete [java.util.concurrent], una lista que, cada vez que se modifica, copia su contenido en un nuevo arreglo. Una iteración en curso continúa, por lo tanto, sobre el arreglo anterior, aunque la lista se modifique mientras tanto. Más adelante veremos por qué esto es esencial aquí. Esta lista es el tipo estándar para las listas de oyentes: la lista se recorre en cada evento, pero rara vez se modifica;
  • líneas 59–65: el método [setTemperature] registra la nueva temperatura y señala el evento si esta supera el umbral;
  • línea 63: la publicación está a cargo del método [fireTemperatureTooHigh], al que se le pasa un objeto [TemperatureTooHighEvent]; este objeto proviene del propio emisor ([this]) y contiene la temperatura que superó el umbral;
  • líneas 68–70: el registro de un oyente lo agrega a la lista. [Objects.requireNonNull] rechaza de inmediato un oyente [null], que de otro modo provocaría una [NullPointerException] mucho más tarde, durante la notificación;
  • líneas 73–75: la cancelación del registro elimina el oyente de la lista. El método [remove] busca el objeto que se va a eliminar mediante [equals]; por lo tanto, hay que pasarle el mismo objeto que se registró;
  • líneas 78–82: la notificación llama al método [temperatureTooHigh] de cada oyente registrado, en el orden en que se registraron. Si no hay oyentes, el bucle no hace nada: no hay casos especiales que manejar.

Esta es la clase [Subscriber]:

// una clase que se registra como oyente del evento
class Subscriber {
    // nombre del suscriptor
    private final String name;
    // número máximo de alertas aceptadas
    private final int nbAlertsMax;
    // número de alertas recibidas
    private int nbAlerts;
    // el oyente, creado una sola vez para poder darlo de baja
    private final TemperatureTooHighListener listener = this::evtTemperatureTooHigh;

    Subscriber(String name, int nbAlertsMax) {
        this.name = name;
        this.nbAlertsMax = nbAlertsMax;
    }

    // registro en un emisor
    void subscribe(Emitter emitter) {
        emitter.addTemperatureTooHighListener(listener);
    }

    // baja
    void unsubscribe(Emitter emitter) {
        emitter.removeTemperatureTooHighListener(listener);
    }

    // manejador del evento TemperatureTooHigh
    private void evtTemperatureTooHigh(TemperatureTooHighEvent e) {
        Emitter emitter = e.getSource();
        IO.println("Subscriber [%s]: the source [%s] reported a temperature too high: [%.1f]"
                .formatted(name, emitter.getName(), e.getTemperature()));
        // superado nbAlertsMax alertas, el suscriptor se da de baja
        nbAlerts++;
        if (nbAlerts == nbAlertsMax) {
            unsubscribe(emitter);
            IO.println("Subscriber [%s]: unsubscribed after %d alert(s)".formatted(name, nbAlerts));
        }
    }
}

Comentarios:

  • líneas 4–6: cada suscriptor se identifica por un nombre y se le asigna el número máximo de alertas que acepta ([nbAlertsMax]);
  • línea 10: el oyente del suscriptor es una referencia a su método privado [evtTemperatureTooHigh]. Vimos con [Lambdas04.java] que dos evaluaciones de [this::evtTemperatureTooHigh] producen dos objetos diferentes. Si escribiéramos [emitter.addTemperatureTooHighListener(this::evtTemperatureTooHigh)] en [subscribe] y luego [emitter.removeTemperatureTooHighListener(this::evtTemperatureTooHigh)] en [unsubscribe], la cancelación de la suscripción no eliminaría nada, ¡y no se mostraría ningún mensaje de error! Por eso creamos el oyente una sola vez y lo almacenamos en un campo;
  • líneas 18–20: suscripción a un emisor. Es responsabilidad del suscriptor; el suscriptor sabe qué objeto debe eliminar para cancelar su suscripción;
  • líneas 23–25: la cancelación de la suscripción elimina el mismo objeto, [listener]. Cada suscriptor tiene su propio objeto, [listener]: [remove] elimina únicamente el que pertenece al suscriptor en cuestión;
  • línea 28: el manejador del evento. Tiene la forma especificada por la interfaz [TemperatureTooHighListener]. Es privado: solo el suscriptor puede registrarlo en un emisor. Otro enfoque muy común consiste en que la propia clase [Subscriber] ([class Subscriber implements TemperatureTooHighListener]) implemente la interfaz del oyente y se registre con [this]. El inconveniente de este enfoque es que hace público el método [temperatureTooHigh], que cualquiera podría entonces llamar;
  • línea 29: gracias a la redefinición de [getSource], el origen del evento es directamente de tipo [Emitter];
  • líneas 30–31: el manejador muestra el nombre del suscriptor, el nombre del emisor que señaló el evento y la temperatura que lo desencadenó. El formato [%.1f] muestra el número real con un decimal, aquí con punto decimal;
  • Líneas 33–37: tras [nbAlertsMax] alertas, el suscriptor cancela su suscripción al emisor. El suscriptor lo hace durante la notificación del evento, desde su propio manejador; es decir, mientras el método [fireTemperatureTooHigh] recorre la lista de oyentes. Esto es seguro gracias a [CopyOnWriteArrayList]: [remove] crea un nuevo arreglo, pero la iteración en curso continúa sobre el anterior.

Por último, aquí está el programa principal:

// manejo de eventos: un emisor y oyentes

void main() {
    // creación de un emisor de eventos
    var e1 = new Emitter("e");
    // creación de dos suscriptores que se registran en e1
    List<Subscriber> subscribers = List.of(new Subscriber("s0", 3), new Subscriber("s1", 1));
    for (Subscriber subscriber : subscribers) {
        subscriber.subscribe(e1);
    }
    // un tercer oyente: una lambda
    e1.addTemperatureTooHighListener(
            e -> IO.println("Log: %.1f °C at %tT".formatted(e.getTemperature(), e.getTime())));

    // se leen las temperaturas desde el teclado
    while (true) {
        String input = IO.readln("Temperature (nothing to stop): ");
        // ¿fin de la entrada? (readln devuelve null si la entrada estándar está cerrada)
        if (input == null || input.isBlank()) {
            break;
        }
        try {
            // se acepta la coma decimal
            double temperature = Double.parseDouble(input.strip().replace(',', '.'));
            // temperatura correcta: se registra en el emisor
            e1.setTemperature(temperature);
        } catch (NumberFormatException ex) {
            // se informa del error
            IO.println("Incorrect temperature");
        }
    }
}

Resultados:

> java Lambdas09.java
Temperature (nothing to stop): 17
Temperature (nothing to stop): 21
Subscriber [s0]: the source [e] reported a temperature too high: [21.0]
Subscriber [s1]: the source [e] reported a temperature too high: [21.0]
Subscriber [s1]: unsubscribed after 1 alert(s)
Log: 21.0 °C at 18:58:41
Temperature (nothing to stop): abc
Incorrect temperature
Temperature (nothing to stop): 22,5
Subscriber [s0]: the source [e] reported a temperature too high: [22.5]
Log: 22.5 °C at 18:58:41
Temperature (nothing to stop): 25
Subscriber [s0]: the source [e] reported a temperature too high: [25.0]
Subscriber [s0]: unsubscribed after 3 alert(s)
Log: 25.0 °C at 18:58:41
Temperature (nothing to stop): 30
Log: 30.0 °C at 18:58:41
Temperature (nothing to stop): 

Comentarios:

  • línea 5: creación del emisor;
  • líneas 7–10: creación de dos suscriptores, [s0] (hasta 3 alertas) y [s1] (1 alerta), que se registran en el emisor;
  • líneas 12–13: un tercer oyente, una lambda, que actúa como registro (log). El tipo del parámetro [e] se infiere a partir del del parámetro [addTemperatureTooHighListener]. El formato [%tT] muestra una hora en la forma [HH:mm:ss]. Esta lambda no puede cancelar su registro: habría tenido que almacenarse en una variable para pasarla a [removeTemperatureTooHighListener]. Por lo tanto, las lambdas escritas directamente en la llamada de registro se reservan para los oyentes que permanecen registrados mientras exista el emisor;
  • líneas 16–31: bucle de ingreso de temperaturas por teclado. [IO.readln(prompt)] muestra el mensaje y lee una línea; devuelve [null] si la entrada estándar está cerrada, lo que se trata como una entrada vacía (línea 19);
  • línea 24: [Double.parseDouble] solo acepta el punto decimal. Para permitir que un usuario francés escriba [22,5], la coma se reemplaza por un punto. Si la entrada no es un número, [parseDouble] lanza una [NumberFormatException], que se intercepta en la línea 27;
  • línea 26: si la temperatura ingresada es válida, se transmite al emisor [e1], que señala el evento [TemperatureTooHigh] si es mayor que 19 °C.

Los resultados muestran (la entrada estándar se alimentó desde un archivo, lo que explica que todas las horas sean idénticas):

  • línea 2: 17 °C no supera el umbral: no hay evento;
  • líneas 3–7: 21 °C desencadena el evento. Los tres oyentes son notificados en el orden en que se registraron. [s1], que acepta una sola alerta, cancela su suscripción de inmediato, pero esto no impide que el registro (log), inscrito después de él, sea notificado;
  • líneas 10–12: [s1] ya no es notificado;
  • líneas 13–16: [s0] recibe su tercera alerta y cancela a su vez su suscripción;
  • línea 18: solo queda el registro (log).

¿Qué ocurriría si simplemente hubiera un [ArrayList] en la línea 45 del primer fragmento, en la clase [Emitter]? Lo probamos: cuando [s1] cancela su suscripción mientras se procesa la lista, los elementos siguientes se omiten y el procesamiento se detiene de inmediato. El registro (log) no es notificado de las temperaturas 21 y 25, sin ningún mensaje de error. En otras configuraciones, la iteración lanza una [ConcurrentModificationException]. Por lo tanto, una lista de oyentes debe admitir siempre modificaciones mientras se la recorre: la [CopyOnWriteArrayList] está diseñada para este fin, y además admite suscripciones y cancelaciones realizadas por otros hilos (capítulo 8).

7.5.3. Eventos de cambio de propiedad

El tipo de evento más común se produce cuando una propiedad de un objeto cambia de valor: otro objeto (una interfaz gráfica de usuario, una caché, un registro) quiere ser notificado de este cambio. La biblioteca de Java proporciona para ello una clase lista para usar, [java.beans.PropertyChangeSupport], que administra por nosotros la lista de oyentes. Los oyentes implementan la interfaz funcional [PropertyChangeListener], cuyo método [void propertyChange(PropertyChangeEvent evt)] recibe un evento que contiene el origen, el nombre de la propiedad y sus valores anterior y nuevo. El programa [Lambdas10.java] lo utiliza:

// eventos de cambio de propiedades: java.beans.PropertyChangeSupport

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;

void main() {
    var thermometer = new Thermometer("living room");
    // un oyente de todas las propiedades
    PropertyChangeListener log = e -> IO.println("Log: %s.%s : %s -> %s".formatted(
            ((Thermometer) e.getSource()).getName(), e.getPropertyName(), e.getOldValue(), e.getNewValue()));
    thermometer.addPropertyChangeListener(log);
    // un oyente solo de la propiedad temperature
    thermometer.addPropertyChangeListener("temperature", e -> {
        if ((double) e.getNewValue() > 19) {
            IO.println("Alert: temperature too high");
        }
    });

    thermometer.setTemperature(18);
    thermometer.setTemperature(21.5);
    // mismo valor: no hay evento
    thermometer.setTemperature(21.5);
    thermometer.setName("lounge");
    // baja del registro
    thermometer.removePropertyChangeListener(log);
    thermometer.setTemperature(22);
    IO.println("remaining listeners: " + thermometer.getNbListeners());
}

// una clase cuyas propiedades notifican sus cambios
class Thermometer {
    // la gestión de los oyentes se delega en un objeto PropertyChangeSupport
    private final PropertyChangeSupport changes = new PropertyChangeSupport(this);
    private String name;
    private double temperature;

    Thermometer(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }

    void setName(String name) {
        String old = this.name;
        this.name = name;
        changes.firePropertyChange("name", old, name);
    }

    double getTemperature() {
        return temperature;
    }

    void setTemperature(double temperature) {
        double old = this.temperature;
        this.temperature = temperature;
        changes.firePropertyChange("temperature", old, temperature);
    }

    // registro y baja de los oyentes
    void addPropertyChangeListener(PropertyChangeListener listener) {
        changes.addPropertyChangeListener(listener);
    }

    void addPropertyChangeListener(String property, PropertyChangeListener listener) {
        changes.addPropertyChangeListener(property, listener);
    }

    void removePropertyChangeListener(PropertyChangeListener listener) {
        changes.removePropertyChangeListener(listener);
    }

    int getNbListeners() {
        return changes.getPropertyChangeListeners().length;
    }
}

Resultados:

1
2
3
4
5
6
7
> java Lambdas10.java
Log: living room.temperature : 0.0 -> 18.0
Log: living room.temperature : 18.0 -> 21.5
Alert: temperature too high
Log: lounge.name : living room -> lounge
Alert: temperature too high
remaining listeners: 1

Comentarios:

  • líneas 3–4: el paquete [java.beans] pertenece al módulo [java.desktop], no al módulo [java.base]: debe importarse explícitamente, incluso en un archivo fuente compacto;
  • Línea 33: la clase [Thermometer] delega la administración de sus oyentes en un objeto [PropertyChangeSupport], construido a partir del origen del evento ([this]). Los métodos de las líneas 62–72 simplemente le transmiten las suscripciones y cancelaciones;
  • Líneas 45–49 y 55–59: cada modificador almacena el valor anterior, registra el nuevo y llama a [firePropertyChange] con el nombre de la propiedad y ambos valores. [firePropertyChange] notifica a los oyentes solo si los dos valores son diferentes: la línea 22 no produce ninguna salida;
  • líneas 9–11: un primer oyente, una lambda almacenada en una variable para poder cancelar su suscripción (línea 25). Está suscrito a todas las propiedades del objeto. [e.getSource()] devuelve un [Object], que debe convertirse. Los valores son objetos: los objetos [double] se han convertido a [Double], cuyo método [toString] utiliza el punto decimal;
  • líneas 13–17: un segundo sensor, registrado únicamente para la propiedad [temperature]. Desencadena una alerta cuando la temperatura supera los 19 °C;
  • líneas 19–26: cambios de propiedades. El cambio de nombre (línea 23) se informa solo al registro (log). En la línea 5 de los resultados, el registro muestra el nuevo nombre del origen, [lounge]: el evento se informa después del cambio;
  • líneas 26–27: tras cancelar la suscripción al registro (log), solo se muestra la alerta, y solo queda un oyente.

Sin escribir una clase de evento ni una interfaz de oyente, obtenemos así un mecanismo completo. Es el que utilizan los componentes gráficos de Swing y los JavaBeans; JavaFX tiene su propio mecanismo, muy similar, basado en propiedades observables.

7.6. Lambdas y la API Stream

En el capítulo 5, utilizamos los métodos de la API Stream ([filter], [map], [sorted]…) pasándoles expresiones lambda. Ahora sabemos qué son estos parámetros: el método [filter] se declara de la siguiente manera en la interfaz [java.util.stream.Stream<T>]: [Stream<T> filter(Predicate<? super T> predicate)].

Su parámetro es un [Predicate]: sirve cualquier método o lambda que reciba un elemento y devuelva un booleano. De manera similar, [map] espera un [Function<? super T, ? extends R>], [sorted] espera un [Comparator], [forEach] espera un [Consumer], [reduce] espera un [BinaryOperator]… Para comprender a fondo cómo funciona la API Stream, escribamos nuestras propias operaciones de filtrado y transformación. Este es el programa [Lambdas11.java]:

// lambdas y la API Stream

void main() {
    List<Integer> numbers = List.of(3, 8, 1, 6, 5, 4, 9, 2);

    // 1 - filter y map esperan un Predicate<T> y una Function<T, R>
    Predicate<Integer> isEven = n -> n % 2 == 0;
    Function<Integer, Integer> square = n -> n * n;
    List<Integer> evenSquares = numbers.stream().filter(isEven).map(square).toList();
    IO.println("Stream: " + evenSquares);

    // 2 - nuestro propio método de filtrado, llamado con una lambda y luego con una referencia a método
    IO.println("filter(n > 4): " + Tools.filter(numbers, n -> n > 4));
    IO.println("filter(isOdd): " + Tools.filter(numbers, Tools::isOdd));

    // 3 - la ejecución es diferida: el predicado solo se invoca en la operación terminal
    Stream<Integer> large = numbers.stream().filter(n -> {
        IO.print("[test " + n + "] ");
        return n > 7;
    });
    IO.println("the stream is defined, nothing has been executed yet");
    large.forEach(n -> IO.print("-> " + n + " "));
    IO.println();

    // 4 - nuestras propias operaciones intermedias con gatherers (Gatherer, Java 24)
    List<String> cities = List.of("Angers", "Paris", "Lyon", "Nantes", "Aix");
    List<String> result = cities.stream()
            .gather(Tools.filter(v -> v.length() <= 5))
            .gather(Tools.transform(String::toUpperCase))
            .toList();
    IO.println("gatherers: " + result);
}

class Tools {
    // filtra una lista con un predicado: el trabajo que realiza filter
    static <T> List<T> filter(List<T> source, Predicate<? super T> predicate) {
        List<T> result = new ArrayList<>();
        for (T element : source) {
            if (predicate.test(element)) {
                result.add(element);
            }
        }
        return result;
    }

    static boolean isOdd(int n) {
        return n % 2 != 0;
    }

    // una operación intermedia de stream que solo deja pasar los elementos que cumplen el predicado
    static <T> Gatherer<T, ?, T> filter(Predicate<? super T> predicate) {
        return Gatherer.of((_, element, downstream) -> !predicate.test(element) || downstream.push(element));
    }

    // una operación intermedia que transforma cada elemento: el equivalente de map
    static <T, R> Gatherer<T, ?, R> transform(Function<? super T, ? extends R> transformation) {
        return Gatherer.of((_, element, downstream) -> downstream.push(transformation.apply(element)));
    }
}

Resultados:

1
2
3
4
5
6
7
> java Lambdas11.java
Stream: [64, 36, 16, 4]
filter(n > 4): [8, 6, 5, 9]
filter(isOdd): [3, 1, 5, 9]
the stream is defined, nothing has been executed yet
[test 3] [test 8] -> 8 [test 1] [test 6] [test 5] [test 4] [test 9] -> 9 [test 2] 
gatherers: [PARIS, LYON, AIX]

Comentarios:

  • Líneas 7–9: la lambda de [filter] se almacena primero en una variable de tipo [Predicate<Integer>] para revelar su tipo. [map], a su vez, recibe una [Function<Integer, Integer>] que transforma cada elemento: esto produce los cuadrados de los números pares;
  • Líneas 36–44: nuestro método [filter]. Es genérico: filtra una lista de elementos de cualquier tipo [T], utilizando un predicado de tipo [Predicate<? super T>]. Recorre la lista, llama al predicado (línea 39) con cada elemento y devuelve la lista de los elementos seleccionados;
  • Línea 13: llamada a [filter] con una lambda. El tipo [T] se infiere de la lista: [Integer]. Línea 14: se le pasa una referencia a un método: [isOdd] (línea 46) recibe un [int]; el compilador agrega la conversión desde [Integer];
  • Líneas 17–20: un predicado detallado que muestra cada elemento que evalúa. El resultado (líneas 5–6) muestra que la definición del flujo no ejecuta nada: el mensaje de la línea 21 se muestra antes de la primera evaluación. Solo cuando la operación terminal [forEach] (línea 22) solicita los elementos se ejecuta el predicado, y las evaluaciones se alternan con las salidas de [forEach]: cada elemento recorre todo el flujo antes de que entre el siguiente. Esta es la ejecución diferida (o perezosa) de los streams. Nuestro método [filter], en cambio, construye toda la lista de resultados antes de devolverla;
  • líneas 51–58: para escribir nuestras propias operaciones intermedias (que son perezosas, como las de la API Stream) utilizamos los recolectores intermedios ([Gatherer], Java 24), que son los equivalentes, para las operaciones intermedias, de los recolectores ([Collector]) utilizados por [collect]. [Gatherer.of] recibe una lambda con tres parámetros, llamada por cada elemento del flujo: un estado (innecesario aquí, de ahí el parámetro anónimo [_]), el elemento y la siguiente etapa del flujo ([downstream]), a la que se le pasa un elemento mediante [downstream.push(...)]. La lambda devuelve [false] para detener el flujo; nuestras funciones nunca lo deciden por sí mismas: devuelven el resultado de [push], que es igual a [false] solo si el componente siguiente ya no desea más elementos (o [true] cuando el filtro descarta un elemento). El filtro (línea 52) transmite solo los elementos que cumplen el predicado; la transformación (línea 57) transmite el resultado de la función aplicada a cada elemento;
  • línea 56: [transform] es doblemente genérico: [T] es el tipo de los elementos recibidos, y [R] es el tipo de los elementos producidos. El parámetro [Function<? super T, ? extends R>] sigue la regla que ya vimos: la función consume [T] y produce [R];
  • líneas 27–30: el método de stream [gather] inserta nuestras operaciones en la cadena, que se escribe de la misma manera que para las operaciones de la API Stream: conservamos las ciudades con hasta 5 letras y luego las ponemos en mayúsculas.

Toda la API Stream está construida sobre este modelo: operaciones que reciben interfaces funcionales y producen nuevos streams, cuyos elementos se calculan solo cuando la operación terminal los solicita.

7.7. Árboles de expresión

Algunos lenguajes, como C#, permiten convertir una lambda no en código ejecutable, sino en una estructura de datos que la describe (un «árbol de expresión»): un programa puede entonces analizar la lambda [t -> t.getLimit() > 20000] y traducirla, por ejemplo, a una cláusula SQL [WHERE limits > 20000] ejecutada por el servidor de base de datos.

Java no tiene un equivalente. Una lambda de Java siempre se compila a código ejecutable: se puede llamar, pero no se puede examinar lo que hace. Por ello, las bibliotecas de acceso a bases de datos recurren a otros medios para expresar una consulta. Hibernate, que veremos en el capítulo 11, ofrece dos soluciones: un lenguaje de consulta similar a SQL pero expresado en términos de clases y propiedades, HQL (["from Bracket t where t.limit > 20000"]), y la API Criteria de Jakarta Persistence, que construye la consulta mediante llamadas a métodos ([cb.gt(t.get("limit"), 20000)]). En ambos casos, la consulta son datos (una cadena o un árbol de objetos) que Hibernate traduce a SQL, mientras que una lambda pasada a [filter] se ejecuta dentro del programa Java.

7.8. Conclusión

Puntos clave de este capítulo:

  • Una interfaz funcional es una interfaz que tiene un único método abstracto. Las interfaces predefinidas del paquete [java.util.function] ([Function], [Supplier], [Consumer], [Predicate], sus variantes de dos parámetros y sus versiones primitivas), junto con [Runnable], [Callable] y [Comparator], suelen eliminar la necesidad de definir interfaces propias; cuando se define una, se anota con [@FunctionalInterface];
  • Una interfaz funcional puede ser implementada por una clase (con nombre o anónima), por una expresión lambda o por una referencia a un método ([Class::staticMethod], [object::method], [Class::instanceMethod], [Class::new]). Una lambda no tiene un tipo propio: lo determina el tipo de destino;
  • Las lambdas capturan las variables locales que las rodean, siempre que esas variables sean efectivamente finales; el estado mutable se maneja mediante un objeto o un campo;
  • los métodos [andThen], [compose], [and], [negate], [comparing], [thenComparing]… construyen nuevas funciones a partir de otras existentes;
  • En Java, una lambda es una instancia de una interfaz: se elige una interfaz funcional para un comportamiento breve y puntual, mientras que se elige una interfaz con varios métodos (o una interfaz «de negocio») para un rol de la aplicación;
  • Un evento se configura mediante el patrón de oyentes: una clase [XxxEvent] derivada de [EventObject], una interfaz [XxxListener], métodos [addXxxListener] / [removeXxxListener], y una lista de oyentes ([CopyOnWriteArrayList]) recorrida por un método [fireXxx]. Para cancelar la suscripción de un oyente, hay que conservar el objeto suscrito. [PropertyChangeSupport] proporciona este mecanismo listo para usar para los cambios de propiedades;
  • la API Stream se basa en operaciones que aceptan interfaces funcionales; Java no tiene árboles de expresión, y Hibernate expresa sus consultas en HQL o mediante la API Criteria.

Las lambdas reaparecerán en todos los capítulos siguientes: un hilo ejecuta un [Runnable], y un [ExecutorService] ejecuta un [Callable] (capítulo 8), un [CompletableFuture] encadena funciones (capítulo 9), y los servicios web de Spring Boot manejan las solicitudes HTTP en métodos que el framework invoca como oyentes (capítulo 13).