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:
Resultados:
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]:
Resultados:
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):
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:
Resultados:
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:
Resultados:
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:
Resultados:
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:
Resultados:
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]:
Resultados:
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:
Resultados:
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]:
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]:
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:
Resultados:
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:
Resultados:
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]:
Resultados:
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).