Skip to content

7. Interfaces funcionais, lambdas e eventos

Em muitos programas, precisamos passar a um método não dados, mas um comportamento: o critério de ordenação, a condição de filtragem ou o processamento a executar quando algo acontece. O Java atende a essa necessidade com um conceito simples no qual todo este capítulo se baseia: a interface funcional, isto é, uma interface que declara apenas um único método abstrato. Um objeto que implementa essa interface “carrega” uma função, que pode ser armazenada em uma variável, passada como parâmetro, retornada como resultado de um método e executada à vontade.

Antes do Java 8 (2014), era preciso escrever uma classe, muitas vezes anônima, para cada comportamento que se queria expressar, o que era verboso. O Java 8 introduziu as expressões lambda e as referências de método, que permitem escrever esse comportamento em uma única linha. Já as usamos, sem entrar em detalhes, com a API Stream no Capítulo 5: em [persons.stream().filter(p -> p.age() >= 18)], passamos um lambda, isto é, uma instância de uma interface funcional, ao método [filter]. Este capítulo explica o que há por trás dessa sintaxe. Ele termina com os eventos, que o Java trata por meio de “listeners”: objetos, muitas vezes lambdas, que se registram em um emissor para serem notificados do que acontece nele. As interfaces gráficas Java (Swing, JavaFX) e os frameworks web se baseiam nesse mecanismo: um clique em um botão ou a chegada de uma requisição (HTTP) são sinalizados aos listeners registrados. Este curso não aborda interfaces gráficas; todos os exemplos são programas de console.

Os programas deste capítulo são arquivos-fonte compactos localizados na pasta [07-lambdas]. Eles são executados com [java LambdasNN.java]. Observe que um arquivo-fonte compacto importa automaticamente todo o módulo [java.base]: as interfaces dos pacotes [java.util.function], [java.util], ou [java.util.concurrent] podem ser usadas ali sem nenhuma instrução [import].

7.1. Interfaces funcionais predefinidas

7.1.1. O conceito de interface funcional

Uma interface funcional é uma interface que tem exatamente um método abstrato. Ela também pode ter quantos métodos [default] e [static] se quiser (ver Capítulo 4): eles não contam. Esse único método abstrato descreve um modelo (também chamado de assinatura ou forma) de função: os tipos de seus parâmetros e o tipo de seu valor de retorno. Uma variável do tipo da interface pode então referenciar qualquer objeto que forneça uma função dessa forma e executá-la chamando o método.

O exemplo mais antigo é a interface [java.lang.Runnable], que existe desde o Java 1.0 e representa uma tarefa a ser executada (voltaremos a ela ao tratar de threads no Capítulo 8). Ela consiste em um único método: [void run();]. Ela descreve uma função:

  • sem parâmetros;
  • sem retornar resultado ([void]).

Há três maneiras de criar um objeto do tipo [Runnable]:

  • escrever uma classe que implemente a interface, nomeada ou anônima. Essa era a única maneira antes do Java 8;
  • escrever uma expressão lambda: [Runnable task = () -> IO.println("task");];
  • escrever uma referência de método para um método existente que tenha a forma correta: [Runnable task = Functions::display;].

Nos dois últimos casos, o próprio compilador cria o objeto que implementa a interface: o lambda ou o método referenciado se torna o corpo do método [run]. A função é então executada chamando o método da interface: [task.run()]. Ao contrário de outras linguagens, o Java não tem uma sintaxe de chamada específica: o método da interface é sempre chamado pelo seu nome ([run], [apply], [test]…).

7.1.2. Interfaces do pacote java.util.function

Antes do Java 8, cada biblioteca definia suas próprias interfaces de método único ([Runnable], [Comparator], [ActionListener]…). O Java 8 introduziu o pacote [java.util.function], que fornece 43 interfaces funcionais genéricas cobrindo praticamente todas as necessidades. As principais são as seguintes:

Interface
Método abstrato
Funções representadas
[Runnable] ([java.lang])
[void run()]
Sem parâmetros, sem resultado
[Supplier<T>]
[T get()]
Sem parâmetros, um resultado: um “fornecedor” (supplier)
[Consumer<T>]
[void accept(T t)]
um parâmetro, sem resultado: um “consumidor” (consumer)
[BiConsumer<T, U>]
[void accept(T t, U u)]
dois parâmetros, sem resultado
[Function<T, R>]
[R apply(T t)]
um parâmetro, um resultado do tipo [R] (sempre o último tipo)
[BiFunction<T, U, R>]
[R apply(T t, U u)]
dois parâmetros, um resultado
[UnaryOperator<T>]
[T apply(T t)]
uma [Function<T, T>]: parâmetro e resultado do mesmo tipo
[BinaryOperator<T>]
[T apply(T t1, T t2)]
uma [BiFunction<T, T, T>]
[Predicate<T>]
[boolean test(T t)]
um parâmetro, um resultado booleano: um “predicado” (predicate)
[BiPredicate<T, U>]
[boolean test(T t, U u)]
dois parâmetros, um resultado booleano
[Comparator<T>] ([java.util])
[int compare(T o1, T o2)]
dois parâmetros do mesmo tipo, um resultado inteiro
[Callable<V>] ([java.util.concurrent])
[V call() throws Exception]
Igual a [Supplier<V>], mas pode lançar uma exceção verificada

Os genéricos do Java se aplicam apenas a tipos objeto: uma [Function<Integer, Integer>] recebe e retorna [Integer], o que exige conversões automáticas (boxing e unboxing) entre [int] e [Integer]. Para evitá-las, o pacote fornece versões especializadas para os tipos primitivos [int], [long], e [double]: [IntBinaryOperator] ([int applyAsInt(int left, int right)]), [IntUnaryOperator], [IntPredicate], [IntSupplier], [IntConsumer], [IntFunction<R>] (com [int] como parâmetro), [ToIntFunction<T>] (com [int] como resultado) e seus equivalentes [Long…] e [Double…]. Não há interface predefinida com três ou mais parâmetros; nesse caso, é preciso definir a sua própria (ver o parágrafo seguinte).

O programa [Lambdas01.java] usa essas interfaces com referências de método:

// as interfaces funcionais predefinidas do Java

void main() {
    // 1 - Runnable: sem parâmetro, sem resultado: void run()
    Runnable task = new Runnable() {
        @Override
        public void run() {
            Functions.display();
        }
    };
    // forma curta: uma referência a método
    task = Functions::display;
    // execução: chamamos o único método abstrato da interface
    task.run();

    // 2 - BiFunction<T, U, R>: dois parâmetros, um resultado
    BiFunction<Integer, Integer, Integer> operation = Functions::add;
    IO.println("operation.apply(2, 3)=" + operation.apply(2, 3));
    // Supplier<T>: sem parâmetro, um resultado
    Supplier<String> greet = Functions::greet;
    IO.println("greet.get()=" + greet.get());
    // versão primitiva: IntBinaryOperator, int applyAsInt(int, int), sem boxing
    IntBinaryOperator multiply = Functions::multiply;
    IO.println("multiply.applyAsInt(2, 3)=" + multiply.applyAsInt(2, 3));

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

    // 4 - Predicate<T>: um parâmetro, um 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 um Predicate
    boolean modified = numbers.removeIf(isEven);
    IO.println("even numbers removed: " + modified + ", remaining: " + numbers);

    // 5 - Comparator<T>: dois parâmetros T, um 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 - uma lambda é um objeto: a instância de uma classe gerada que implementa a interface
    IO.println("class: " + operation.getClass().getName());
    IO.println("interfaces: " + Arrays.toString(operation.getClass().getInterfaces()));
}

// os métodos referenciados, agrupados em uma classe
// (a classe implícita de um arquivo-fonte compacto não pode ser nomeada)
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]

Comentários:

  • Linhas 5–10: criação de um objeto [Runnable] por meio de uma classe anônima, isto é, uma classe sem nome, declarada e instanciada exatamente onde é necessária. Ela implementa o método [run], que chama o método [display] da linha 52. Essa era a sintaxe obrigatória antes do Java 8;
  • linha 12: a mesma coisa usando uma referência de método: [Functions::display] refere-se ao método estático [display] da classe [Functions]. O compilador verifica se ele tem a forma do método [run] (sem parâmetros, sem valor de retorno) e cria o objeto [Runnable] que o chama. Essa é hoje a sintaxe padrão;
  • linha 14: a função é executada chamando o método da interface. O método [display] da linha 52 é executado (linha 2 dos resultados);
  • Linhas 48–50: os métodos referenciados estão agrupados em uma classe chamada [Functions]. Teríamos preferido escrevê-los diretamente no arquivo, ao lado de [main], e nomeá-los [Lambdas01::add]. No entanto, a classe implícita que envolve um arquivo-fonte compacto não pode ser nomeada no código (o compilador retorna [cannot find symbol]);
  • linha 17: [BiFunction<Integer, Integer, Integer>] refere-se a uma função com dois parâmetros, [Integer], e que retorna um [Integer] (o último tipo genérico). O método [add] da linha 56, que trabalha com [int], é adequado: o compilador acrescenta as conversões entre [int] e [Integer]. A função é chamada por meio de seu método [apply] (linha 18);
  • linha 20: [Supplier<String>] refere-se a uma função sem parâmetros que retorna uma string. Ela é chamada por meio de seu método [get];
  • linha 23: a versão primitiva [IntBinaryOperator] opera diretamente sobre valores [int], sem conversão. Seu método se chama [applyAsInt]. Esse é o tipo preferido para tarefas de uso intensivo de cálculo;
  • Linha 27: [Consumer<String>] refere-se a uma função que recebe um parâmetro, [String], e não retorna nada. O método estático [IO.println(Object)] é adequado: uma [String] é um [Object]. Ela é executada por meio de seu método [accept];
  • linha 31: um predicado é uma função que retorna um booleano; ele é executado por meio de seu método [test] (linha 32). O método [removeIf] da interface [Collection] (linha 35) espera um parâmetro do tipo [Predicate]: ele remove da coleção todos os elementos para os quais o predicado retorna [true], e retorna [true] se removeu pelo menos um elemento;
  • linha 40: o método [sort] da interface [List] aceita um [Comparator] que compara dois elementos (o resultado pode ser negativo, zero ou positivo, como em [compareTo]). Aqui, os nomes são ordenados em ordem crescente de tamanho. O método [compareLengths] (linha 72) usa [Integer.compare], que compara dois [int] sem o risco de estouro (que uma simples subtração não garante);
  • Linhas 44–45: uma referência de método, assim como um lambda, é um objeto. Sua classe, exibida na linha 10 dos resultados, é uma classe gerada em tempo de execução pela máquina virtual, cujo nome contém [$$Lambda] seguido de um endereço que muda de uma execução para outra. Na linha 11 dos resultados, vemos que essa classe implementa a interface [BiFunction]. Um lambda não é, portanto, um novo tipo de objeto: é uma instância de uma classe comum que implementa uma interface funcional.

7.2. Definindo suas próprias interfaces funcionais

As interfaces predefinidas costumam ser suficientes, mas você pode definir as suas. Basta escrever uma interface com um único método abstrato, por exemplo:

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

Essa interface representa uma função que recebe dois inteiros e retorna um inteiro. Em comparação com *[IntBinaryOperator]*, o tipo *[Operation] tem um nome que descreve sua finalidade, seu método tem um nome descritivo ([calculate] em vez de [applyAsInt]*), e seus parâmetros têm nomes ([n1], [n2]) que as ferramentas de desenvolvimento exibem. Ela é precedida pela anotação [@FunctionalInterface]: isso não é obrigatório, mas instrui o compilador a verificar se a interface é funcional e documenta a intenção do desenvolvedor.

Uma variável [op] do tipo [Operation] referencia apenas uma função por vez. Ao contrário de outras linguagens, que oferecem “delegates multicast”, o Java não oferece uma maneira de armazenar várias funções em uma única variável e executá-las todas com uma única chamada: quando necessário, as funções são colocadas em uma lista e executadas uma a uma. É exatamente o que faremos com os listeners de eventos.

Considere o exemplo [Lambdas02.java]:

// definindo suas próprias interfaces funcionais

void main() {
    // uma variável do tipo Operation recebe o método estático increase
    Operation op = Calculations::increase;
    // executamos a operação
    int n = op.calculate(4, 7);
    IO.println("n=" + n);

    // criação de um objeto c1 do tipo Calculations
    var c1 = new Calculations();
    // armazenamos em op o método add do objeto c1
    op = c1::add;
    n = op.calculate(2, 3);
    IO.println("n=" + n);
    // depois o método subtract de c1
    op = c1::subtract;
    n = op.calculate(2, 3);
    IO.println("n=" + n);

    // uma variável referencia apenas uma função: para executar várias, usamos uma 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));
    }

    // um método default da interface constrói uma nova operação
    Operation squaredSum = ((Operation) c1::add).then(x -> x * x);
    IO.println("squaredSum.calculate(1, 2)=" + squaredSum.calculate(1, 2));

    // Operation e IntBinaryOperator têm a mesma forma, mas são dois tipos diferentes
    IntBinaryOperator other = op::calculate;
    IO.println("other.applyAsInt(5, 1)=" + other.applyAsInt(5, 1));

    // uma interface 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));
}

// definição de uma interface funcional: um único método abstrato
// que aceita dois inteiros como parâmetros e retorna um inteiro
@FunctionalInterface
interface Operation {
    int calculate(int n1, int n2);

    // um método default não conta: a interface continua funcional
    default Operation then(IntUnaryOperator next) {
        return (n1, n2) -> next.applyAsInt(calculate(n1, n2));
    }
}

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

// uma classe cujos métodos têm a forma da interface Operation
class Calculations {
    // dois métodos de instância
    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;
    }

    // um 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)=*****

Comentários:

  • linhas 47–55: definição da interface funcional [Operation]. Em um arquivo-fonte compacto, as declarações de tipos (classes, interfaces, records etc.) podem ser colocadas antes ou depois do método [main]; nós as colocamos depois;
  • Linhas 52–54: uma interface funcional pode ter métodos [default]. O método [then] constrói uma nova [Operation]: esse método executa a operação atual e depois aplica a função [next] ao seu resultado. Ele retorna um lambda, que examinaremos na próxima seção. Os métodos de composição das interfaces predefinidas ([andThen], [compose]… etc.) são escritos segundo esse modelo, que discutiremos mais adiante;
  • Linhas 64–81: a classe [Calculations] tem dois métodos de instância, [add] e [subtract], e um método estático, [increase], todos os três com a mesma forma do método [calculate];
  • linha 5: a variável [op] é do tipo [Operation]. Atribui-se a ela uma referência ao método estático [Calculations.increase];
  • linha 7: a operação é executada pelo método [calculate]. O método [Calculations.increase] é executado, com os parâmetros passados a [calculate];
  • linha 11: é criada uma instância [c1] da classe [Calculations] ;
  • Linha 13: a referência [c1::add] refere-se ao método [add] do objeto [c1]. [increase] era um método estático, enquanto [add] é um método de instância: isso não faz diferença. No segundo caso, o objeto criado pelo compilador também guarda o objeto [c1] sobre o qual o método será chamado;
  • linha 17: faz-se o mesmo com o método de instância [subtract];
  • linhas 22–28: para executar várias operações, elas são colocadas em uma lista [List<Operation>], que é então percorrida. Referências de método e lambdas podem ser misturados (linha 25). Cada resultado é recuperado (linhas 8–12 dos resultados);
  • linha 31: o método [default] [then] é aplicado à operação [c1::add]. A conversão [(Operation)] é necessária: uma referência de método não tem tipo próprio, e não é possível chamar um método nela até que o compilador saiba qual interface ela implementa (voltaremos a isso). [squaredSum.calculate(1, 2)] calcula (1+2)², isto é, 9 (linhas 13–14 dos resultados);
  • linha 35: [Operation] e [IntBinaryOperator] têm exatamente a mesma forma, mas são dois tipos diferentes, sem relação de herança. A atribuição [IntBinaryOperator other = op;] seria rejeitada ([incompatible types: Operation cannot be converted to IntBinaryOperator]). Em contrapartida, a referência de método [op::calculate] tem a forma correta: ela cria um [IntBinaryOperator] que chama o método [calculate] do objeto [op] ([c1::subtract] nesta etapa do programa);
  • linhas 57–61: uma interface funcional pode ser genérica. [Transformation<T, R>] representa uma função que recebe um [T] e retorna um [R]: ela equivale a [Function<T, R>], com nomes escolhidos por nós;
  • Linha 39: [String::length] é adequado para uma [Transformation<String, Integer>]: o método [length] será chamado sobre a string passada como parâmetro. Linha 40: ["*"::repeat] refere-se ao método [repeat(int)] do objeto string ["*"]; ele recebe um inteiro e retorna uma string. São dois tipos diferentes de referências de método, que discutiremos em detalhes na próxima seção.

A anotação [@FunctionalInterface] entra em ação se um segundo método abstrato, por exemplo [int invert(int n);], for acidentalmente adicionado à interface [Operation]. O compilador então sinaliza a própria anotação e cada um dos lambdas e referências de método que usam a interface (saída 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

As mensagens do compilador [javac] estão em inglês: o JDK não fornece tradução para o francês.

7.3. Classes anônimas, expressões lambda e referências de método

7.3.1. Das classes anônimas aos lambdas

Nos exemplos anteriores, cada função é um método nomeado escrito em outro lugar do programa. Para funções curtas usadas uma única vez, isso é trabalhoso. Até o Java 7, a única alternativa era a classe anônima: a classe que implementa a interface é escrita no ponto em que o objeto é criado. O Java 8 introduziu uma sintaxe muito mais concisa, as expressões lambda, que praticamente substituíram as classes anônimas para interfaces funcionais. O programa [Lambdas03.java] demonstra as diferentes formas:

// de classes anônimas a expressões lambda

void main() {
    // 1 - uma classe anônima: a classe que implementa a interface é escrita no próprio local
    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 - a mesma coisa com uma expressão lambda (Java 8): parâmetros -> corpo
    IntBinaryOperator subtract = (int n1, int n2) -> {
        return n1 - n2;
    };
    IO.println("block-body lambda: subtract(2, 3)=" + subtract.applyAsInt(2, 3));

    // 3 - os tipos dos parâmetros são inferidos da interface de destino
    IntBinaryOperator multiply = (n1, n2) -> n1 * n2;
    IO.println("expression-body lambda: multiply(2, 3)=" + multiply.applyAsInt(2, 3));

    // 4 - um único parâmetro: os parênteses são opcionais
    IntUnaryOperator square = x -> x * x;
    Predicate<String> isEmpty = s -> s.isEmpty();
    IO.println("square(7)=" + square.applyAsInt(7) + ", isEmpty(\"\")=" + isEmpty.test(""));

    // 5 - sem parâmetro: parênteses vazios
    Supplier<String> greet = () -> "Hello";
    Runnable beep = () -> IO.println("beep!");
    IO.println(greet.get());
    beep.run();

    // 6 - um corpo em bloco com várias instruções
    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 sem nome (Java 22): não precisamos de seus valores
    BiConsumer<Object, String> listener = (_, _) -> IO.println("event received");
    listener.accept(null, "click");

    // 8 - uma lambda passada diretamente como parâmetro de 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]

Comentários:

  • Linhas 5–10: uma classe anônima. O operador [new] é seguido do nome da interface, de parênteses vazios e do corpo de uma classe que implementa a interface. O compilador gera uma classe (com um nome de sua escolha, [Lambdas03$1]) e cria uma instância dela. São seis linhas para expressar [n1 + n2];
  • linhas 14–16: a mesma coisa usando uma expressão lambda. Escrevemos a lista de parâmetros, o operador [->] (uma seta, que se lê “resulta em”) e, depois, o corpo. O nome da interface e o nome do método desapareceram: o compilador os conhece pelo tipo da variável, chamado de tipo-alvo do lambda. Um lambda cujo corpo é um bloco delimitado por chaves é um lambda com corpo em bloco;
  • linha 20: os tipos dos parâmetros desapareceram. O compilador os infere a partir do tipo-alvo [IntBinaryOperator]: [n1] e [n2] são do tipo [int]. O corpo se reduz a uma expressão, cujo valor é o resultado do lambda: é um lambda com corpo em expressão. Essa é a forma mais comum;
  • linha 24: com um único parâmetro cujo tipo não é especificado, os parênteses são opcionais. [x -> x * x] lê-se “x resulta em x vezes x”. Linha 25: um lambda com um parâmetro do tipo [String] que retorna um booleano: é um [Predicate<String>];
  • linhas 29–30: sem parâmetros, usam-se parênteses vazios. Um lambda cujo corpo é uma chamada de método do tipo [void] é adequado para um [Runnable];
  • linhas 35–40: um lambda com corpo em bloco pode conter quaisquer instruções: declarações, laços, testes etc.;
  • linha 44: o caractere sublinhado [_] designa um parâmetro anônimo (Java 22). Ele é usado quando a assinatura da interface exige parâmetros de que o lambda não precisa, o que é comum em listeners de eventos. Vários desses parâmetros podem ser incluídos no mesmo lambda;
  • linhas 49–51: o uso mais comum dos lambdas é passá-los diretamente como parâmetros a um método que espera uma interface funcional. Compare com [Lambdas01.java]: não é mais necessário escrever um método [isEven]. Aqui trabalhamos sobre uma cópia da lista, porque [removeIf] modifica a lista sobre a qual opera;
  • linha 52: um lambda do tipo [Comparator<Integer>] que inverte a comparação usual: a lista é ordenada em ordem decrescente.

Vamos rever as formas de uma expressão lambda:

Forma
Exemplo
parâmetros tipados, corpo em bloco
[(int a, int b) -> { return a + b; }]
parâmetros sem tipo, corpo em expressão
[(a, b) -> a + b]
um único parâmetro sem tipo
[x -> x * x]
sem parâmetros
[() -> "Hello"]
parâmetros anônimos
[(_, _) -> IO.println("received")]
Parâmetros declarados com [var]
[(var a, var b) -> a + b]

Os parâmetros são todos tipados ou todos sem tipo: não é possível misturar os dois. Em um corpo em bloco, um lambda que retorna um resultado deve ter uma instrução [return] em todos os caminhos de execução, exatamente como um método.

Um lambda não é exatamente uma abreviação de classe anônima. Em uma classe anônima, [this] refere-se à instância da classe anônima; em um lambda, [this] refere-se ao objeto do método que contém o lambda. Além disso, uma classe anônima cria um novo escopo: ela pode declarar uma variável com o mesmo nome de uma variável do método, o que um lambda não pode fazer. Por fim, uma classe anônima pode implementar uma interface com vários métodos ou herdar de uma classe abstrata, o que é impossível com um lambda. Neste curso, usaremos lambdas sempre que possível.

7.3.2. Informações adicionais: tipo-alvo e referências de método

O programa [Lambdas04.java] define o conceito de tipo-alvo e apresenta os quatro tipos de referências de método:

// mais sobre lambdas e referências a métodos

void main() throws Exception {
    // 1 - uma lambda não tem tipo por si só: o contexto o determina
    // var twice = x -> x * 2;  // rejeitado: a lambda precisa de um tipo de destino
    var twice = (IntUnaryOperator) x -> x * 2;
    IO.println("twice(21)=" + twice.applyAsInt(21));
    // o mesmo texto de lambda pode implementar duas interfaces diferentes
    Supplier<String> supplier = () -> "Hello";
    Callable<String> callable = () -> "Hello";
    IO.println(supplier.get() + " / " + callable.call());

    // 2 - parâmetros declarados com var (Java 11): permite anotá-los ou torná-los final
    BinaryOperator<String> concatenate = (final var s1, final var s2) -> s1 + s2;
    IO.println(concatenate.apply("lam", "bda"));

    // 3 - os quatro tipos de referências 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 instância de um objeto dado: object::method
    String name = "Pierre";
    Supplier<String> inUpperCase = name::toUpperCase;
    IO.println("inUpperCase.get()=" + inUpperCase.get());
    // c) método de instância de um objeto qualquer: Class::instanceMethod
    //    o objeto sobre o qual o método é chamado se torna o primeiro 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) construtor: 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 - exceções verificadas: Callable.call pode lançá-las, Supplier.get não
    Callable<Integer> read = () -> {
        throw new IOException("missing file");
    };
    try {
        read.call();
    } catch (IOException ex) {
        IO.println("exception received: " + ex.getMessage());
    }

    // 5 - cada avaliação de uma lambda ou de uma referência a método pode criar um novo 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

Comentários:

  • Linha 5: um lambda não tem tipo próprio. Seu tipo é determinado pelo contexto: o tipo da variável que o recebe, o tipo do parâmetro ao qual ele é passado ou o tipo especificado por uma conversão. A declaração [var twice = x -> x * 2;] é, portanto, rejeitada pelo compilador: [cannot infer type for local variable twice (lambda expression needs an explicit target-type)]. Ele não saberia qual interface implementar;
  • linha 6: com uma conversão para [IntUnaryOperator], o tipo-alvo é conhecido, e [var] passa a ser válido. Na prática, escreveríamos [IntUnaryOperator twice = x -> x * 2;] em vez disso;
  • Linhas 9–10: o mesmo lambda, [() -> "Hello"], implementa aqui um [Supplier<String>] e ali um [Callable<String>]. São dois objetos de classes diferentes, que compartilham apenas a forma de seu método;
  • linha 14: desde o Java 11, os parâmetros de lambda podem ser declarados com [var], o que permite acrescentar-lhes um modificador ([final]) ou uma anotação, algo que não é possível com um parâmetro sem tipo;
  • linhas 17–37: os quatro tipos de referências de método:
    • linha 19: uma referência a um método estático, [Class::staticMethod]. [Integer::parseInt] equivale ao lambda [s -> Integer.parseInt(s)];
    • linha 23: uma referência a um método de instância de um objeto específico, [object::method]. [name::toUpperCase] equivale a [() -> name.toUpperCase()]: o objeto [name] é fixado de uma vez por todas;
    • Linhas 27–28: uma referência a um método de instância de qualquer objeto de uma classe, [Class::instanceMethod]. O objeto sobre o qual o método será chamado ainda não é conhecido: ele se torna o primeiro parâmetro da função. [String::toUpperCase] equivale a [s -> s.toUpperCase()] (um parâmetro), e [String::compareToIgnoreCase] equivale a [(s1, s2) -> s1.compareToIgnoreCase(s2)] (dois parâmetros), daí [Comparator<String>];
    • linhas 32–34: a referência a um construtor, [Class::new]. [ArrayList::new] equivale a [() -> new ArrayList<>()]; [StringBuilder::new], com um tipo-alvo de [Function<String, StringBuilder>], seleciona o construtor que recebe uma string; [int[]::new] cria um array do tamanho passado como parâmetro;
  • linha 37: as três funções de criação são usadas; [reverse] inverte o conteúdo de [StringBuilder] (linha 8 dos resultados);
  • Linhas 40–47: uma diferença significativa entre [Callable] e [Supplier]. O método [call] é declarado com [throws Exception]: um lambda do tipo [Callable] pode, portanto, lançar uma exceção verificada (ver Capítulo 3), neste caso uma [IOException]. O método [get] de [Supplier] não declara nenhuma exceção: o mesmo lambda do tipo [Supplier<Integer>] seria rejeitado ([unreported exception IOException; must be caught or declared to be thrown]). Nenhuma interface do pacote [java.util.function] permite exceções verificadas: um lambda que lança uma deve capturá-la ele mesmo ou usar uma interface cujo método a declare. É por isso que [main] é declarado com [throws Exception] (linha 3): as chamadas a [callable.call()] (linha 11) e [read.call()] (linha 44) poderiam teoricamente lançar qualquer [Exception], que o [catch] da linha 45, limitado a [IOException], não intercepta;
  • linhas 50–52: duas avaliações da mesma referência de método [name::toUpperCase] produzem dois objetos diferentes, que nem [==] nem [equals] consideram iguais (linha 10 dos resultados). Guarde isso: será importante ao cancelar a inscrição em um listener de eventos.

Uma referência de método é simplesmente uma notação abreviada para um lambda que apenas chama um método. Usamo-la quando melhora a legibilidade: [String::length] em vez de [s -> s.length()].

7.3.3. Compondo funções

As interfaces funcionais predefinidas têm métodos [default] e [static] que criam novas funções a partir de funções existentes, como o método [then] de nossa interface [Operation]. O programa [Lambdas05.java] lista os principais:

// compondo funções: andThen, compose, and, or, negate, comparing, thenComparing

void main() {
    // 1 - Function: andThen (primeiro esta, depois a outra) e compose (primeiro a outra)
    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));
    // uma cadeia de processamento construída a partir de uma lista de funções
    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 encadeia dois processamentos sobre o mesmo 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 constrói uma função a partir de um comparador
    BinaryOperator<Person> youngest = BinaryOperator.minBy(Comparator.comparingInt(Person::age));
    IO.println("youngest(Paul, Mélanie)=" + youngest.apply(persons.get(0), persons.get(3)));
}

// mantém os elementos que satisfazem o 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)

Comentários:

  • linha 7: [f.andThen(g)] retorna o resultado da aplicação de [f] primeiro, depois de [g]: (5 + 1) × 2 = 12;
  • linha 8: [f.compose(g)] aplica primeiro [g], depois [f]: 5 × 2 + 1 = 11;
  • linhas 10–15: uma cadeia de processamento construída dinamicamente. Partimos da função identidade ([Function.identity()], que deixa seu parâmetro inalterado) e acrescentamos, por meio de [andThen], cada etapa da lista. A função resultante [normalize] remove os espaços no início e no fim, converte o texto para minúsculas e substitui os espaços por hifens. Cada chamada a [andThen] cria uma nova função: as funções existentes nunca são modificadas. Da mesma forma, a lista de etapas poderia ser lida de um arquivo de configuração;
  • linhas 19–25: os predicados são combinados com [and] (e), [or] (ou) e [negate] (não). O método estático [Predicate.not] (Java 11) retorna a negação de um predicado: ele permite escrever [Predicate.not(String::isEmpty)], enquanto [String::isEmpty.negate()] é rejeitado (uma referência de método não tem tipo até que tenha um tipo-alvo);
  • Linhas 28–34: [c1.andThen(c2)] retorna um [Consumer], que executa [c1] e depois [c2] sobre o mesmo valor. Essa é a maneira mais simples, em Java, de executar várias operações com uma única chamada. Linha 30: [log::add] é uma referência ao método [add] do objeto [log];
  • linha 39: [Comparator.comparing(f)] constrói um comparador que compara os valores de [f] (aqui, a idade); [thenComparing] especifica o critério de desempate a usar em caso de empate (aqui, o nome). O record [Person] (linhas 60–65) fornece os acessores [age()] e [name()]; redefinimos seu método [toString] para abreviar a saída exibida;
  • linhas 41–42: [comparingInt] evita converter a idade para [Integer], [reversed] inverte a ordem obtida até então, e a segunda forma de [thenComparing] recebe, além do critério, o comparador a ser usado para esse critério: [Comparator.reverseOrder()], a ordem natural invertida;
  • linhas 45–46: [BinaryOperator.minBy] converte um comparador em uma função que retorna o menor de seus dois parâmetros;
  • linhas 50–58: o método [filter] usado para esses testes. Seu parâmetro é do tipo [Predicate<? super T>] em vez de [Predicate<T>]: ele aceita, portanto, para filtrar uma lista de [String], tanto um [Predicate<String>] quanto um [Predicate<Object>] ou um [Predicate<CharSequence>]. Essa é a regra seguida em toda a biblioteca Java: um parâmetro funcional que consome [T] é declarado com [? super T], e um parâmetro que produz eles é declarado com [? extends T].

Esses métodos permitem escrever processamentos complexos combinando funções simples, sem escrever uma única classe. Voltaremos a eles com a API Stream.

7.3.4. Captura de variáveis e closures

Um lambda pode usar as variáveis locais do método em que é definido. Diz-se que ele captura essas variáveis. O Java impõe uma regra importante a esse respeito, que distingue a linguagem de muitas outras (C#, JavaScript, Python): uma variável local capturada deve ser “efetivamente final” (“effectively final”), ou seja, nunca ser modificada após sua inicialização, nem no método nem no lambda. O programa [Lambdas06.java] demonstra o que essa regra permite e proíbe:

// captura de variáveis e closures

// um campo da classe implícita: as lambdas podem modificá-lo
int nbCalls;

void main() {
    // 1 - uma lambda pode usar as variáveis locais que a cercam...
    int threshold = 5;
    Predicate<Integer> exceeds = n -> n > threshold;
    IO.println("threshold=" + threshold + " : exceeds(7)=" + exceeds.test(7));
    // ... desde que sejam efetivamente finais: threshold = 10; seria rejeitado
    int otherThreshold = 10;
    Predicate<Integer> exceedsOther = n -> n > otherThreshold;
    IO.println("threshold=" + otherThreshold + " : exceeds(7)=" + exceedsOther.test(7));

    // 2 - uma lambda não pode modificar uma variável local capturada...
    // int total = 0; IntConsumer accumulate = n -> total += n;  // rejeitado
    // ... mas pode modificar o objeto que ela referencia
    AtomicInteger total = new AtomicInteger();
    IntConsumer accumulate = n -> total.addAndGet(n);
    accumulate.accept(3);
    accumulate.accept(4);
    IO.println("total=" + total.get());
    // ... ou um campo do objeto atual (a lambda captura this)
    Runnable count = () -> nbCalls++;
    count.run();
    count.run();
    IO.println("nbCalls=" + nbCalls);

    // 3 - um closure: o objeto capturado sobrevive ao método que o criou
    IntSupplier counterA = createCounter();
    IntSupplier counterB = createCounter();
    IO.println("A : " + counterA.getAsInt() + " " + counterA.getAsInt() + " " + counterA.getAsInt());
    IO.println("B : " + counterB.getAsInt() + " " + counterB.getAsInt());

    // 4 - o laço for: a variável i muda, ela não pode ser capturada
    List<Runnable> actions = new ArrayList<>();
    for (int i = 0; i < 3; i++) {
        // actions.add(() -> IO.print(i + " "));  // rejeitado: i não é efetivamente final
        int copy = i;
        actions.add(() -> IO.print(copy + " "));
    }
    IO.print("for, capture of a copy: ");
    actions.forEach(Runnable::run);
    IO.println();

    // o laço for-each declara uma nova variável a cada iteração: ela é efetivamente 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();
}

// um método que retorna uma função
static IntSupplier createCounter() {
    // objeto local capturado pela lambda retornada
    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 

Comentários:

  • Linha 9: o lambda usa a variável local [threshold] declarada na linha 8. [threshold] não é um parâmetro do lambda; é uma variável capturada. A variável nunca é modificada: ela é efetivamente final, sem necessidade de declará-la como [final] (o que era exigido até o Java 7 para classes anônimas);
  • Linha 11: se acrescentássemos [threshold = 10;] depois da criação do lambda, o compilador rejeitaria o lambda da linha 9: *[local variables referenced from a lambda expression must be final or effectively final]. Para mudar o limite, criamos outra variável e outro lambda (linhas 12–13). Por outro lado, a pergunta “o lambda vê o valor da variável no momento de sua criação ou no momento de sua execução?” não se coloca em Java: os dois são idênticos. Na verdade, o lambda recebe uma cópia* do valor da variável quando é criado;
  • linha 17: pela mesma razão, um lambda não pode modificar uma variável local capturada: [n -> total += n] é rejeitado, com a mesma mensagem;
  • Linhas 19–23: a variável capturada [total] não muda; ela continua referenciando o mesmo objeto, [AtomicInteger]. No entanto, nada impede o lambda de modificar o estado desse objeto. A classe [AtomicInteger] do pacote [java.util.concurrent.atomic] encapsula um inteiro mutável ([addAndGet], [incrementAndGet], [get]…), que pode ser usado com segurança por várias threads (Capítulo 8). Encontramos também a técnica do array de um único elemento ([int[] total = {0};] seguido de [total[0] += n]), que não tem essa última propriedade;
  • linhas 4 e 25–28: a regra se aplica apenas a variáveis locais. Um lambda pode ler e modificar os campos do objeto atual: ele captura então a referência [this], que por sua vez não muda. O campo [nbCalls] é um campo da classe implícita do arquivo-fonte compacto; como o método [main] é um método de instância, o lambda pode incrementá-lo;
  • Linhas 58–62: o método *[createCounter] retorna um lambda que captura sua variável local *[value]*. Normalmente, uma variável local é destruída quando o método termina. Aqui, o lambda retornado guardou uma cópia da referência [value], e o objeto referenciado [AtomicInteger] sobrevive a [createCounter]* enquanto o lambda existir. A combinação do lambda com os valores que ele captura é chamada de “closure”. Para criá-la, a máquina virtual armazena os valores capturados em campos do objeto que cria para o lambda;
  • linhas 31–34: cada chamada a [createCounter] cria um novo objeto [AtomicInteger] e, portanto, um novo contador, independente dos outros. Os resultados (linhas 6–7) confirmam isso;
  • linhas 38–42: em um laço [for] padrão, a variável [i] é modificada a cada iteração ([i++]): ela não é efetivamente final, e o lambda da linha 39 seria rejeitado. Em outras linguagens, essa captura é permitida e leva a um resultado inesperado: os três lambdas compartilham a mesma variável [i] e todos exibem 3, seu valor no final do laço. O Java elimina essa armadilha em tempo de compilação. A solução é declarar uma variável [copy] no corpo do laço, uma nova a cada iteração e nunca modificada (linha 40), de modo que cada lambda capture a sua;
  • linhas 49–51: com o laço “para cada elemento” [for], o problema não surge: a variável [j] é uma nova variável a cada iteração, nunca modificada e, portanto, efetivamente final;
  • linhas 44 e 53: o método [forEach] das coleções espera um [Consumer] e o executa sobre cada elemento. Aqui, cada elemento é ele próprio um *[Runnable]*, e a referência **[Runnable::run]*** (qualquer objeto do tipo *[Runnable]*, sobre o qual *[run] é chamado) o executa.

A regra sobre variáveis efetivamente final pode parecer restritiva. No entanto, ela tem uma justificativa sólida: uma lambda pode ser executada mais tarde, ou em outra thread (Capítulo 8). Se ela pudesse modificar as variáveis locais de um método que talvez já tenha terminado, ou lê-las enquanto outra thread as modifica, teríamos um comportamento difícil de prever. Ao exigir que as variáveis permaneçam inalteradas, o Java evita essas situações; quando um estado compartilhado e mutável é realmente necessário, ele é explicitado por meio de um objeto ([AtomicInteger], coleção…) cujo comportamento em relação às threads é especificado.

7.4. Interfaces funcionais ou interfaces?

Em muitas linguagens, o conceito de "função passada como parâmetro" (ponteiro de função em C, delegate em C#) é distinto do conceito de interface, e podemos nos perguntar qual escolher. Em Java, a questão se coloca de outra forma, porque os dois conceitos são um só: uma lambda é uma instância de uma interface. Vejamos o exemplo [Lambdas07.java], que é semelhante a [Lambdas02.java]:

// um parâmetro de tipo interface funcional

void main() {
    // execução do método add
    IO.println(execute(Methods::add, 2, 3));
    // execução do método subtract
    IO.println(execute(Methods::subtract, 2, 3));
    // execução de um método da biblioteca Java com a forma adequada
    IO.println(execute(Math::max, 2, 3));
    // execução de uma lambda: nenhum método nomeado é necessário
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
}

// execução de uma operação recebida como parâmetro
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

// dois métodos com a forma da interface 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;
    }
}

// a interface 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

Na linha 15, o método *[execute] espera um parâmetro do tipo definido pela interface funcional *[Operation] na linha 34. Isso nos permite passar a ele diferentes funções: métodos estáticos da nossa classe [Methods] (linhas 5 e 7), um método da biblioteca Java com a forma correta (linha 9: entre as sobrecargas de *[Math.max]*, o compilador escolhe ***[int max(int a, int b)]*) e até mesmo uma lambda (linha 11): não foi necessário escrever um método de multiplicação. Esse polimorfismo é o das interfaces, abordado no Capítulo 4: o programa [Lambdas08.java] demonstra isso implementando a mesma interface com classes:

// classes que implementam a interface funcional

void main() {
    // execução da operação Add
    IO.println(execute(new Add(), 2, 3));
    // execução da operação Subtract
    IO.println(execute(new Subtract(), 2, 3));
    // o mesmo método execute continua aceitando lambdas
    IO.println(execute((n1, n2) -> n1 * n2, 2, 3));
    // uma interface com dois métodos abstratos não aceita mais uma lambda: é necessária uma classe
    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));
}

// execução do único método da interface Operation
static int execute(Operation op, int n1, int n2) {
    return op.calculate(n1, n2);
}

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

// uma interface que não é funcional: dois métodos abstratos
interface NamedOperation extends Operation {
    String name();
}

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

// classe 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

Comentários:

  • Linhas 31–33: a interface [Operation] define um método [calculate]. Ela não é anotada com [@FunctionalInterface]: a anotação é apenas uma verificação, e qualquer interface com um único método abstrato é funcional;
  • linhas 41–47 e 50–56: as classes *[Add] e *[Subtract] implementam a interface *[Operation]*;
  • linhas 26–28: o método [execute], cujo primeiro parâmetro é do tipo da interface [Operation]. Ele recebe, sucessivamente, uma instância da classe [Add], uma instância da classe [Subtract] (linhas 5 e 7) e, em seguida, uma lambda (linha 9). Para [execute], esses três objetos são do mesmo tipo: objetos que implementam [Operation];
  • Linhas 36–38: a interface [NamedOperation] herda o método [calculate] e acrescenta um método [name]. Com dois métodos abstratos, ela deixa de ser funcional: não pode mais ser implementada por meio de uma lambda; é necessária uma classe, neste caso uma classe anônima (linhas 11–21).

Esses dois exemplos mostram que, em Java, não é preciso escolher entre dois mecanismos: um método que espera uma interface de método único aceita objetos de classes escritas para a ocasião, referências de método e lambdas indistintamente. A verdadeira questão, então, é: a interface deve ser funcional, com um único método, ou deve ter vários métodos?

  • Uma interface de método único, seja predefinida ([Function], [Predicate]…) ou não, mostra-se mais flexível de usar: qualquer método existente com a forma correta serve, e uma lambda permite até escrever a função no próprio ponto da chamada. Não há classe a escrever. Essa flexibilidade explica por que as bibliotecas modernas (a API Stream, a programação assíncrona do Capítulo 9, o Spring) fazem amplo uso de interfaces funcionais;
  • uma interface com vários métodos volta a levar vantagem assim que o comportamento a implementar envolve várias operações inter-relacionadas ([calculate] e [name] acima), ou quando exige estado e identidade próprios.

É o caso da interface [ITaxDao] na camada [dao] do Capítulo 6: embora tenha apenas um método, [List<TaxBracket> getTaxBrackets()], suas implementações têm estado (as faixas lidas, o nome do arquivo), são criadas pelo contêiner de injeção de dependência e representam um papel claramente nomeado dentro da aplicação. Um [Supplier<List<TaxBracket>>] teria bastado tecnicamente, mas seria muito menos descritivo. Reservamos, portanto, as interfaces funcionais para comportamentos curtos e pontuais (um critério, uma transformação, uma ação) e as interfaces "de negócio" para os papéis da aplicação, independentemente do número de métodos que contenham.

7.5. Tratamento de eventos

7.5.1. O modelo de listeners

As interfaces funcionais são usadas para configurar eventos. O Java não tem uma palavra-chave dedicada a eventos: ele usa um conjunto de convenções, conhecido como "modelo de listeners", estabelecido já no Java 1.1 para componentes gráficos e JavaBeans. Uma classe [C1] que deseja sinalizar um evento [Xxx] procede da seguinte forma:

  • Uma classe [XxxEvent], derivada de [java.util.EventObject], encapsula as informações do evento. [EventObject] armazena o objeto que disparou o evento, chamado de origem, que é obtido por meio de [getSource()];
  • uma interface [XxxListener], que estende a interface vazia [java.util.EventListener] (um simples marcador), define o(s) método(s) que será(ão) chamado(s) quando o evento ocorrer. Com um único método, ela é uma interface funcional: um listener pode ser uma lambda;
  • A classe [C1] gerencia uma lista de listeners e oferece dois métodos públicos para se inscrever nela e cancelar a inscrição: [addXxxListener(XxxListener l)] e [removeXxxListener(XxxListener l)];
  • Quando uma instância [c1] de [C1] deseja sinalizar o evento, ela cria um objeto [XxxEvent] e chama o método de cada listener registrado, passando-lhe esse objeto. Por convenção, essa notificação é feita por um método protegido [fireXxx(XxxEvent e)] ("fire", disparar), que uma classe derivada pode sobrescrever para modificar a forma como o evento é publicado;
  • se um objeto [c2] deseja ser notificado do evento [Xxx] do objeto [c1], ele se registra usando [c1.addXxxListener(...)]. Pode cancelar a inscrição por meio de [c1.removeXxxListener(...)] quando não quiser mais ser notificado. Como [c1] gerencia uma lista, objetos diferentes podem se inscrever para ser notificados do mesmo evento.

Nesse cenário, temos:

  • uma classe que sinaliza (também chamada de "publica" ou "emite") um evento;
  • objetos que são notificados desse evento. Diz-se que eles se inscrevem ou se registram no evento: são os listeners, ou tratadores de eventos;
  • uma interface de listener que define a assinatura dos métodos que serão notificados do evento.

Este é o padrão de projeto Observer: o emissor não conhece seus assinantes; ele apenas os notifica. Esse modelo oferece a mesma proteção que uma palavra-chave dedicada: a lista de listeners é um campo privado do emissor. Do lado de fora, só é possível se inscrever ou cancelar a inscrição; não se pode limpar a lista, substituir os outros listeners nem disparar o evento no lugar do emissor.

7.5.2. Um exemplo: temperatura excessivamente alta

Considere o seguinte exemplo:

  • Uma classe chamada [Emitter] encapsula uma temperatura. Quando essa temperatura ultrapassa um certo limite, um evento deve ser disparado. Chamaremos esse evento de [TemperatureTooHigh]. As informações sobre esse evento serão encapsuladas em um objeto [TemperatureTooHighEvent], e os listeners implementarão a interface [TemperatureTooHighListener];
  • uma classe chamada [Subscriber] se registra como listener do evento mencionado. Quando é notificada do evento, ela exibe uma mensagem no console. Um assinante cancela a inscrição automaticamente depois de receber um número especificado de alertas;
  • Um programa de console cria um emissor e dois assinantes. Ele lê temperaturas pelo teclado e as armazena no emissor. Se alguma for alta demais, o emissor sinaliza o evento [TemperatureTooHigh].

Todas essas classes estão reunidas no arquivo-fonte compacto [Lambdas09.java], que apresentamos em três partes. Primeiro, aqui estão a classe do evento, a interface do listener e a classe [Emitter]:

// a informação transportada pelo evento
class TemperatureTooHighEvent extends EventObject {
    @Serial
    private static final long serialVersionUID = 1L;
    // temperatura no momento do evento
    private final double temperature;
    // hora do evento
    private final LocalTime time = LocalTime.now();

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

    // a fonte é necessariamente um Emitter: sobrescrevemos getSource com um tipo mais preciso
    @Override
    public Emitter getSource() {
        return (Emitter) super.getSource();
    }

    double getTemperature() {
        return temperature;
    }

    LocalTime getTime() {
        return time;
    }
}

// a interface que os ouvintes de eventos devem implementar
@FunctionalInterface
interface TemperatureTooHighListener extends EventListener {
    void temperatureTooHigh(TemperatureTooHighEvent e);
}

// a classe que sinaliza o evento
class Emitter {
    // limite que dispara o evento
    static final double THRESHOLD = 19;
    // nome do emissor
    private final String name;
    // temperatura observada
    private double temperature;
    // os listeners 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) {
            // sinalizamos o evento aos listeners
            fireTemperatureTooHigh(new TemperatureTooHighEvent(this, temperature));
        }
    }

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

    // cancelamento do registro de um listener
    void removeTemperatureTooHighListener(TemperatureTooHighListener listener) {
        listeners.remove(listener);
    }

    // notificação do evento a todos os listeners registrados
    protected void fireTemperatureTooHigh(TemperatureTooHighEvent e) {
        for (TemperatureTooHighListener listener : listeners) {
            listener.temperatureTooHigh(e);
        }
    }
}

Comentários:

  • linhas 1–28: a classe [TemperatureTooHighEvent] deriva de [EventObject], conforme a convenção. Seu construtor (linhas 10–13) passa a origem do evento ao construtor de [EventObject] ([super(source)]) e armazena a temperatura que disparou o evento. Acrescentamos o horário do evento, [time] (linha 8). Os campos são [final], e a classe tem apenas acessores somente de leitura: um listener não deve poder modificar as informações do evento para os listeners seguintes;
  • linhas 3–4: [EventObject] implementa a interface [Serializable] (para que os eventos possam ser registrados em log ou transmitidos pela rede). O compilador, ao usar a opção [-Xlint:all], passa então a exigir que cada classe derivada declare um número de versão [serialVersionUID]. A anotação [@Serial] (Java 14) sinaliza esse campo específico ao compilador;
  • linhas 16–19: o método [getSource] de [EventObject] retorna um [Object]. Nós o redefinimos com um tipo de retorno mais específico, [Emitter], o que o Java permite (tipo de retorno covariante): os listeners não precisarão converter a origem por cast. Não podemos usar um *[record]* aqui: um record não pode herdar de nenhuma classe e, portanto, não pode herdar de *[EventObject]*;
  • Linhas 30–34: a interface do listener. Ela estende [EventListener] e declara um único método, [temperatureTooHigh], que recebe o objeto do evento: trata-se de uma interface funcional;
  • linha 39: o limite de temperatura acima do qual o evento [TemperatureTooHigh] é disparado;
  • linha 41: o emissor tem um nome para identificação;
  • linha 45: a lista de listeners registrados. É uma [CopyOnWriteArrayList] do pacote [java.util.concurrent], uma lista que, sempre que é modificada, copia seu conteúdo para um novo array. Uma iteração em andamento continua, portanto, no array antigo, mesmo que a lista seja modificada nesse meio-tempo. Veremos adiante por que isso é essencial aqui. Essa lista é o tipo padrão para listas de listeners: a lista é percorrida a cada evento, mas raramente é modificada;
  • linhas 59–65: o método [setTemperature] registra a nova temperatura e sinaliza o evento se ela ultrapassar o limite;
  • linha 63: a publicação é feita pelo método [fireTemperatureTooHigh], ao qual é passado um objeto [TemperatureTooHighEvent]; esse objeto tem origem no próprio emissor ([this]) e contém a temperatura que ultrapassou o limite;
  • linhas 68–70: o registro de um listener o adiciona à lista. [Objects.requireNonNull] rejeita imediatamente um listener [null], que de outra forma provocaria uma [NullPointerException] muito depois, durante a notificação;
  • linhas 73–75: o cancelamento do registro remove o listener da lista. O método [remove] procura o objeto a ser removido usando [equals]; portanto, é preciso passar-lhe o mesmo objeto que foi registrado;
  • linhas 78–82: a notificação chama o método [temperatureTooHigh] de cada listener registrado, na ordem em que foram registrados. Se não houver listeners, o laço não faz nada: não há casos especiais a tratar.

Aqui está a classe [Subscriber]:

// uma classe que se registra como listener do evento
class Subscriber {
    // nome do assinante
    private final String name;
    // número máximo de alertas aceitos
    private final int nbAlertsMax;
    // número de alertas recebidos
    private int nbAlerts;
    // o listener, criado uma única vez para poder ter o registro cancelado
    private final TemperatureTooHighListener listener = this::evtTemperatureTooHigh;

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

    // registro em um emissor
    void subscribe(Emitter emitter) {
        emitter.addTemperatureTooHighListener(listener);
    }

    // cancelamento do registro
    void unsubscribe(Emitter emitter) {
        emitter.removeTemperatureTooHighListener(listener);
    }

    // tratador do 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()));
        // além de nbAlertsMax alertas, o assinante cancela a assinatura
        nbAlerts++;
        if (nbAlerts == nbAlertsMax) {
            unsubscribe(emitter);
            IO.println("Subscriber [%s]: unsubscribed after %d alert(s)".formatted(name, nbAlerts));
        }
    }
}

Comentários:

  • linhas 4–6: cada assinante é identificado por um nome e recebe o número máximo de alertas que aceita ([nbAlertsMax]);
  • linha 10: o listener do assinante é uma referência ao seu método privado [evtTemperatureTooHigh]. Vimos com [Lambdas04.java] que duas avaliações de [this::evtTemperatureTooHigh] produzem dois objetos diferentes. Se escrevêssemos [emitter.addTemperatureTooHighListener(this::evtTemperatureTooHigh)] em [subscribe] e depois [emitter.removeTemperatureTooHighListener(this::evtTemperatureTooHigh)] em [unsubscribe], o cancelamento da inscrição não removeria nada, e nenhuma mensagem de erro seria exibida! Por isso criamos o listener uma só vez e o armazenamos em um campo;
  • linhas 18–20: inscrição em um emissor. Essa é responsabilidade do assinante; o assinante sabe qual objeto remover para cancelar a inscrição;
  • linhas 23–25: o cancelamento da inscrição remove o mesmo objeto, [listener]. Cada assinante tem seu próprio objeto, [listener]: [remove] remove apenas o que pertence ao assinante em questão;
  • linha 28: o tratador de eventos. Ele tem a forma especificada pela interface [TemperatureTooHighListener]. É privado: somente o assinante pode registrá-lo em um emissor. Outra abordagem muito comum é fazer a própria classe [Subscriber] ([class Subscriber implements TemperatureTooHighListener]) implementar a interface do listener e se registrar com [this]. A desvantagem dessa abordagem é que ela torna público o método [temperatureTooHigh], que qualquer um poderia então chamar;
  • linha 29: graças à redefinição de [getSource], a origem do evento é diretamente do tipo [Emitter];
  • linhas 30–31: o tratador exibe o nome do assinante, o nome do emissor que informou o evento e a temperatura que o disparou. O formato [%.1f] exibe o número real com uma casa decimal, aqui com ponto decimal;
  • Linhas 33–37: após [nbAlertsMax] alertas, o assinante cancela sua inscrição no emissor. O assinante faz isso durante a notificação do evento, a partir de seu próprio tratador, isto é, enquanto o método [fireTemperatureTooHigh] percorre a lista de listeners. Isso é seguro graças a [CopyOnWriteArrayList]: [remove] cria um novo array, mas a iteração em andamento continua no antigo.

Por fim, aqui está o programa principal:

// tratamento de eventos: um emissor e listeners

void main() {
    // criação de um emissor de eventos
    var e1 = new Emitter("e");
    // criação de dois assinantes que se registram em e1
    List<Subscriber> subscribers = List.of(new Subscriber("s0", 3), new Subscriber("s1", 1));
    for (Subscriber subscriber : subscribers) {
        subscriber.subscribe(e1);
    }
    // um terceiro listener: uma lambda
    e1.addTemperatureTooHighListener(
            e -> IO.println("Log: %.1f °C at %tT".formatted(e.getTemperature(), e.getTime())));

    // lemos as temperaturas do teclado
    while (true) {
        String input = IO.readln("Temperature (nothing to stop): ");
        // fim da entrada? (readln retorna null se a entrada padrão estiver fechada)
        if (input == null || input.isBlank()) {
            break;
        }
        try {
            // aceitamos a vírgula decimal
            double temperature = Double.parseDouble(input.strip().replace(',', '.'));
            // temperatura correta - registramos no emissor
            e1.setTemperature(temperature);
        } catch (NumberFormatException ex) {
            // informamos o erro
            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): 

Comentários:

  • linha 5: criação do emissor;
  • linhas 7–10: criação de dois assinantes, [s0] (até 3 alertas) e [s1] (1 alerta), que são registrados no emissor;
  • linhas 12–13: um terceiro listener, uma lambda, que funciona como log. O tipo do parâmetro [e] é inferido a partir do parâmetro de [addTemperatureTooHighListener]. O formato [%tT] exibe um horário na forma [HH:mm:ss]. Essa lambda não pode ter o registro cancelado: seria preciso tê-la armazenado em uma variável para passá-la a [removeTemperatureTooHighListener]. Portanto, as lambdas escritas diretamente na chamada de registro ficam reservadas a listeners que permanecem registrados enquanto o emissor existir;
  • linhas 16–31: laço de leitura das temperaturas pelo teclado. [IO.readln(prompt)] exibe o prompt e lê uma linha; retorna [null] se a entrada padrão estiver fechada, o que é tratado como uma entrada vazia (linha 19);
  • linha 24: [Double.parseDouble] aceita apenas o ponto decimal. Para permitir que um usuário francês digite [22,5], a vírgula é substituída por um ponto. Se a entrada não for um número, [parseDouble] dispara uma [NumberFormatException], que é interceptada na linha 27;
  • linha 26: se a temperatura digitada for válida, ela é transmitida ao emissor [e1], que sinaliza o evento [TemperatureTooHigh] se ela for superior a 19 °C.

Os resultados mostram (a entrada padrão foi alimentada por um arquivo, o que explica por que todos os horários são idênticos):

  • linha 2: 17 °C não ultrapassa o limite: nenhum evento;
  • linhas 3–7: 21 °C dispara o evento. Os três listeners são notificados na ordem em que foram registrados. [s1], que aceita apenas um alerta, cancela a inscrição imediatamente, mas isso não impede que o log, registrado depois dele, seja notificado;
  • linhas 10–12: [s1] não é mais notificado;
  • linhas 13–16: [s0] recebe seu terceiro alerta e, por sua vez, cancela a inscrição;
  • linha 18: resta apenas o log.

O que aconteceria se houvesse simplesmente uma [ArrayList] na linha 45 do primeiro trecho, na classe [Emitter]? Nós testamos: quando [s1] cancela a inscrição enquanto a lista está sendo processada, os itens seguintes são ignorados e o processamento para imediatamente. O log não é notificado das temperaturas 21 e 25, sem nenhuma mensagem de erro. Em outras configurações, a iteração dispara uma [ConcurrentModificationException]. Uma lista de listeners deve, portanto, sempre suportar modificações durante a iteração: a [CopyOnWriteArrayList] foi concebida para isso e também suporta inscrições e cancelamentos feitos por outras threads (Capítulo 8).

7.5.3. Eventos de mudança de propriedade

O tipo de evento mais comum ocorre quando uma propriedade de um objeto muda de valor: outro objeto (uma interface gráfica, um cache, um log) deseja ser notificado dessa mudança. A biblioteca Java fornece para isso uma classe pronta para uso, [java.beans.PropertyChangeSupport], que gerencia a lista de listeners para nós. Os listeners implementam a interface funcional [PropertyChangeListener], cujo método [void propertyChange(PropertyChangeEvent evt)] recebe um evento contendo a origem, o nome da propriedade e seus valores antigo e novo. O programa [Lambdas10.java] o utiliza:

// eventos de mudança de propriedade: java.beans.PropertyChangeSupport

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

void main() {
    var thermometer = new Thermometer("living room");
    // um listener de todas as propriedades
    PropertyChangeListener log = e -> IO.println("Log: %s.%s : %s -> %s".formatted(
            ((Thermometer) e.getSource()).getName(), e.getPropertyName(), e.getOldValue(), e.getNewValue()));
    thermometer.addPropertyChangeListener(log);
    // um listener apenas da propriedade temperature
    thermometer.addPropertyChangeListener("temperature", e -> {
        if ((double) e.getNewValue() > 19) {
            IO.println("Alert: temperature too high");
        }
    });

    thermometer.setTemperature(18);
    thermometer.setTemperature(21.5);
    // mesmo valor: nenhum evento
    thermometer.setTemperature(21.5);
    thermometer.setName("lounge");
    // cancelamento do registro do log
    thermometer.removePropertyChangeListener(log);
    thermometer.setTemperature(22);
    IO.println("remaining listeners: " + thermometer.getNbListeners());
}

// uma classe cujas propriedades sinalizam suas mudanças
class Thermometer {
    // o gerenciamento dos listeners é delegado a um 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 e cancelamento do registro dos listeners
    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

Comentários:

  • linhas 3–4: o pacote [java.beans] pertence ao módulo [java.desktop], e não ao módulo [java.base]: ele deve ser importado explicitamente, mesmo em um arquivo-fonte compacto;
  • Linha 33: a classe [Thermometer] delega o gerenciamento de seus listeners a um objeto [PropertyChangeSupport], construído a partir da origem do evento ([this]). Os métodos das linhas 62–72 simplesmente repassam a ele as inscrições e os cancelamentos;
  • Linhas 45–49 e 55–59: cada modificador armazena o valor antigo, registra o novo e chama [firePropertyChange] com o nome da propriedade e os dois valores. [firePropertyChange] notifica os listeners somente se os dois valores forem diferentes: a linha 22 não produz nenhuma saída;
  • linhas 9–11: um primeiro listener, uma lambda armazenada em uma variável para que possa ter a inscrição cancelada (linha 25). Ele está inscrito para todas as propriedades do objeto. [e.getSource()] retorna um [Object], que precisa ser convertido por cast. Os valores são objetos: os objetos [double] foram convertidos em [Double], cujo método [toString] usa o ponto decimal;
  • linhas 13–17: um segundo sensor, registrado somente para a propriedade [temperature]. Ele dispara um alerta quando a temperatura ultrapassa 19 °C;
  • linhas 19–26: mudanças de propriedade. A mudança de nome (linha 23) é informada apenas ao log. Na linha 5 dos resultados, o log exibe o novo nome da origem, [lounge]: o evento é informado depois da mudança;
  • linhas 26–27: depois de cancelar a inscrição no log, apenas o alerta é exibido, e resta apenas um listener.

Sem escrever uma classe de evento nem uma interface de listener, obtemos assim um mecanismo completo. É o usado pelos componentes gráficos Swing e pelos JavaBeans; o JavaFX tem seu próprio mecanismo, muito semelhante, baseado em propriedades observáveis.

7.6. Lambdas e a API Stream

No Capítulo 5, usamos os métodos da API Stream ([filter], [map], [sorted]…) passando-lhes expressões lambda. Agora sabemos o que são esses parâmetros: o método [filter] é declarado da seguinte forma na interface [java.util.stream.Stream<T>]: [Stream<T> filter(Predicate<? super T> predicate)].

Seu parâmetro é um [Predicate]: qualquer método ou lambda que receba um elemento e retorne um booleano serve. Da mesma forma, [map] espera um [Function<? super T, ? extends R>], [sorted] espera um [Comparator], [forEach] espera um [Consumer], [reduce] espera um [BinaryOperator]… Para entender plenamente como funciona a API Stream, vamos escrever nossas próprias operações de filtragem e transformação. Este é o programa [Lambdas11.java]:

// lambdas e a Stream API

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

    // 1 - filter e map esperam um Predicate<T> e uma 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 - nosso próprio método de filtragem, chamado com uma lambda e depois com uma referência de método
    IO.println("filter(n > 4): " + Tools.filter(numbers, n -> n > 4));
    IO.println("filter(isOdd): " + Tools.filter(numbers, Tools::isOdd));

    // 3 - a execução é adiada: o predicado só é chamado pela operação 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 - nossas próprias operações intermediárias com 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 uma lista com um predicado: o trabalho que filter faz
    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;
    }

    // uma operação intermediária de stream que deixa passar apenas os elementos que satisfazem o predicado
    static <T> Gatherer<T, ?, T> filter(Predicate<? super T> predicate) {
        return Gatherer.of((_, element, downstream) -> !predicate.test(element) || downstream.push(element));
    }

    // uma operação intermediária que transforma cada elemento: o 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]

Comentários:

  • Linhas 7–9: a lambda de [filter] é primeiro armazenada em uma variável do tipo [Predicate<Integer>] para revelar seu tipo. [map], por sua vez, recebe uma [Function<Integer, Integer>] que transforma cada elemento: isso produz os quadrados dos números pares;
  • Linhas 36–44: nosso método [filter]. Ele é genérico: filtra uma lista de elementos de qualquer tipo [T], usando um predicado do tipo [Predicate<? super T>]. Ele percorre a lista, chama o predicado (linha 39) para cada elemento e retorna a lista dos elementos selecionados;
  • Linha 13: chamada de [filter] com uma lambda. O tipo [T] é inferido a partir da lista: [Integer]. Linha 14: uma referência de método é passada a ele: [isOdd] (linha 46) recebe um [int]; o compilador acrescenta a conversão a partir de [Integer];
  • Linhas 17–20: um predicado verboso que exibe cada elemento que testa. O resultado (linhas 5–6) mostra que a definição do fluxo não executa nada: a mensagem da linha 21 é exibida antes do primeiro teste. Somente quando a operação terminal [forEach] (linha 22) solicita os elementos é que o predicado é executado, e os testes se alternam com as exibições de [forEach]: cada elemento percorre todo o fluxo antes que o próximo entre nele. Essa é a execução tardia (ou lazy) dos streams. Nosso método [filter], por outro lado, constrói a lista de resultados inteira antes de retorná-la;
  • linhas 51–58: para escrever nossas próprias operações intermediárias, que são lazy como as da API Stream, usamos os coletores intermediários ([Gatherer], Java 24), que são os equivalentes, para operações intermediárias, dos coletores ([Collector]) usados por [collect]. [Gatherer.of] recebe uma lambda com três parâmetros, chamada para cada elemento do fluxo: um estado (desnecessário aqui, daí o parâmetro anônimo [_]), o elemento e a etapa seguinte do fluxo ([downstream]), à qual um elemento é passado por meio de [downstream.push(...)]. A lambda retorna [false] para interromper o fluxo; nossas funções nunca decidem isso por conta própria: elas retornam o resultado de [push], que é igual a [false] somente se o componente seguinte não quiser mais elementos (ou [true] quando o filtro descarta um elemento). O filtro (linha 52) transmite apenas os elementos que satisfazem o predicado; a transformação (linha 57) transmite o resultado da função aplicada a cada elemento;
  • linha 56: [transform] é duplamente genérico: [T] é o tipo dos elementos recebidos, e [R] é o tipo dos elementos produzidos. O parâmetro [Function<? super T, ? extends R>] segue a regra que já encontramos: a função consome [T] e produz [R];
  • linhas 27–30: o método de stream [gather] insere nossas operações na cadeia, que se escreve da mesma forma que para as operações da API Stream: mantemos as cidades com até 5 letras e depois as colocamos em maiúsculas.

Toda a API Stream é construída sobre esse modelo: operações que recebem interfaces funcionais e produzem novos streams, cujos elementos só são calculados quando a operação terminal os solicita.

7.7. Árvores de expressão

Algumas linguagens, como o C#, permitem converter uma lambda não em código executável, mas em uma estrutura de dados que a descreve (uma "árvore de expressão"): um programa pode então analisar a lambda [t -> t.getLimit() > 20000] e traduzi-la, por exemplo, em uma cláusula SQL [WHERE limits > 20000] executada pelo servidor de banco de dados.

O Java não tem nada equivalente. Uma lambda Java é sempre compilada em código executável: você pode chamá-la, mas não pode examinar o que ela faz. As bibliotecas de acesso a banco de dados usam, portanto, outros meios para expressar uma consulta. O Hibernate, que abordaremos no Capítulo 11, oferece duas soluções: uma linguagem de consulta semelhante ao SQL, mas expressa em termos de classes e propriedades, HQL (["from Bracket t where t.limit > 20000"]), e a API Criteria do Jakarta Persistence, que constrói a consulta por meio de chamadas de método ([cb.gt(t.get("limit"), 20000)]). Em ambos os casos, a consulta é um dado (uma string ou uma árvore de objetos) que o Hibernate traduz em SQL, ao passo que uma lambda passada a [filter] é executada dentro do programa Java.

7.8. Conclusão

Principais pontos deste capítulo:

  • Uma interface funcional é uma interface que tem apenas um método abstrato. As interfaces predefinidas do pacote [java.util.function] ([Function], [Supplier], [Consumer], [Predicate], suas variantes de dois parâmetros e suas versões primitivas), junto com [Runnable], [Callable] e [Comparator], geralmente eliminam a necessidade de definir as suas próprias; quando uma é definida, ela é anotada com [@FunctionalInterface];
  • uma interface funcional pode ser implementada por uma classe (nomeada ou anônima), por uma expressão lambda ou por uma referência de método ([Class::staticMethod], [object::method], [Class::instanceMethod], [Class::new]). Uma lambda não tem tipo próprio: o tipo-alvo o determina;
  • as lambdas capturam as variáveis locais que as cercam, desde que essas variáveis sejam efetivamente final; o estado mutável é tratado por meio de um objeto ou de um campo;
  • os métodos [andThen], [compose], [and], [negate], [comparing], [thenComparing]… constroem novas funções a partir de funções existentes;
  • em Java, uma lambda é uma instância de uma interface: escolhe-se uma interface funcional para comportamentos curtos e pontuais, enquanto uma interface com vários métodos (ou uma interface "de negócio") é escolhida para um papel da aplicação;
  • um evento é configurado por meio do padrão listener: uma classe [XxxEvent] derivada de [EventObject], uma interface [XxxListener], métodos [addXxxListener] / [removeXxxListener], e uma lista de listeners ([CopyOnWriteArrayList]) percorrida por um método [fireXxx]. Para cancelar a inscrição de um listener, é preciso guardar o objeto inscrito. [PropertyChangeSupport] fornece esse mecanismo pronto para mudanças de propriedade;
  • a API Stream é construída sobre operações que aceitam interfaces funcionais; o Java não tem árvores de expressão, e o Hibernate expressa suas consultas em HQL ou por meio da API Criteria.

As lambdas reaparecerão em todos os capítulos seguintes: uma thread executa um [Runnable], e um [ExecutorService] executa um [Callable] (Capítulo 8), um [CompletableFuture] encadeia funções (Capítulo 9), e os serviços web do Spring Boot tratam as requisições HTTP em métodos que o framework chama como listeners (Capítulo 13).