Comportamento como Valor — Lambdas e Interfaces Funcionais

A primeira aula da Fase 4: como passar um comportamento como argumento em uma linha, as interfaces funcionais da biblioteca, as referências a métodos e o que muda no uso das coleções.

"Tempo, Dinheiro e Padrões" fechou a Fase 3 com uma observação: os programas continuam escritos com laços, acumuladores e classes anônimas de seis linhas para dizer "compare pela idade". Esta aula abre a Fase 4 com a ideia que muda esse estilo: um comportamento pode ser tratado como um valor, guardado numa variável, passado como argumento e devolvido por um método. O Java expressa isso com as expressões lambda, introduzidas no Java 8, em 2014, a maior mudança da linguagem desde os genéricos. Você vai ver como elas nascem das classes anônimas que já conhece, que interfaces as recebem, como ficam ainda mais curtas com referências a métodos, e como elas cumprem três promessas deixadas nas aulas anteriores.

Da classe anônima à lambda

Em "Ordem e Critério", um comparador de alunos por idade era escrito assim:

Comparator<Aluno> porIdade = new Comparator<Aluno>() {
    @Override
    public int compare(Aluno a, Aluno b) {
        return Integer.compare(a.idade(), b.idade());
    }
};

Olhe o que é realmente informação nessas seis linhas: os parâmetros a e b, e a expressão Integer.compare(a.idade(), b.idade()). Todo o resto o compilador já sabe. Que é um Comparator<Aluno> está na declaração da variável. Que o método se chama compare e devolve int, a interface diz. Uma expressão lambda escreve só o que é informação:

Comparator<Aluno> porIdade = (Aluno a, Aluno b) -> Integer.compare(a.idade(), b.idade());

E como os tipos dos parâmetros também podem ser deduzidos, a forma usual é ainda mais curta:

Comparator<Aluno> porIdade = (a, b) -> Integer.compare(a.idade(), b.idade());

Lê-se: "dados a e b, o resultado é Integer.compare(...)". A seta -> separa os parâmetros do corpo. As formas possíveis:

() -> 42                             // sem parâmetros
s -> s.isBlank()                     // um parâmetro: os parênteses são opcionais
(a, b) -> a + b                      // vários parâmetros
(a, b) -> {                          // corpo com várias instruções: chaves e return
    int soma = a + b;
    return soma * 2;
}

Quando o corpo é uma única expressão, o valor dela é o resultado, sem return. Quando precisa de várias instruções, vai entre chaves, com return explícito, como um método comum.

Interfaces funcionais

Uma lambda não tem tipo próprio. Ela sempre implementa uma interface funcional: uma interface com exatamente um método abstrato. Comparator é uma. O tipo da lambda vem do contexto em que ela aparece, o seu tipo alvo: a mesma lambda (a, b) -> a + b pode ser um Comparator, um BinaryOperator<Integer> ou outra interface qualquer com um método de dois parâmetros, conforme a variável ou o parâmetro que a recebe.

Métodos default e estáticos não contam na regra do método abstrato único. Comparator tem vários métodos default, como reversed e thenComparing, e continua sendo uma interface funcional. A anotação @FunctionalInterface declara a intenção e faz o compilador verificar:

@FunctionalInterface
interface Validador<T> {
    boolean valido(T valor);

    default Validador<T> e(Validador<T> outro) {
        return v -> valido(v) && outro.valido(v);
    }
}

Validador<String> naoVazio = s -> !s.isBlank();
Validador<String> tamanhoOk = s -> s.length() <= 10;
Validador<String> nomeValido = naoVazio.e(tamanhoOk);

IO.println(nomeValido.valido("Ana"));                  // true
IO.println(nomeValido.valido(""));                     // false
IO.println(nomeValido.valido("Maximiliano Silva"));    // false

Uma interface anotada com dois métodos abstratos é recusada: Unexpected @FunctionalInterface annotation ... is not a functional interface. Repare no método default e: ele devolve uma lambda, construída a partir de duas outras. É uma forma de compor comportamentos que vai reaparecer várias vezes.

As interfaces funcionais da biblioteca

Criar uma interface para cada formato de função seria cansativo. O pacote java.util.function traz as mais comuns, prontas:

Predicate<String> vazio = s -> s.isBlank();
Function<String, Integer> tamanho = s -> s.length();
Supplier<LocalDate> hoje = () -> LocalDate.of(2026, 9, 25);
Consumer<String> gritar = s -> IO.println(s.toUpperCase() + "!");
UnaryOperator<String> inverter = s -> new StringBuilder(s).reverse().toString();
BinaryOperator<Integer> maior = (a, b) -> a >= b ? a : b;

IO.println(vazio.test("  ") + " " + tamanho.apply("lambda") + " " + hoje.get());   // true 6 2026-09-25
gritar.accept("olá");                                                               // OLÁ!
IO.println(inverter.apply("Java") + " " + maior.apply(3, 9));                       // avaJ 9

Os nomes são um vocabulário que vale decorar, porque aparecem em toda a biblioteca e em todos os frameworks. Quando um método recebe um Predicate<Produto>, você sabe imediatamente que ele quer um teste sobre um produto.

Por causa do custo do autoboxing de "Escreva uma Vez para Todo Tipo", existem versões especializadas para primitivos, como IntPredicate, IntFunction<R>, ToIntFunction<T>, IntUnaryOperator e IntBinaryOperator, e as equivalentes para long e double. IntPredicate par = n -> n % 2 == 0; testa inteiros sem criar nenhum objeto Integer.

Referências a métodos

Muitas lambdas apenas chamam um método que já existe: s -> s.length(), s -> Integer.parseInt(s). Para esses casos, há uma forma ainda mais curta, a referência a método, com :::

Function<String, Integer> converter = Integer::parseInt;       // estático
IO.println(converter.apply("42") + 1);                          // 43

String prefixo = "Item: ";
Function<String, String> rotular = prefixo::concat;             // de um objeto específico
IO.println(rotular.apply("caneta"));                            // Item: caneta

Function<Produto, String> nome = Produto::nome;                 // de um objeto qualquer do tipo
Predicate<Produto> caro = Produto::caro;

BiFunction<String, Double, Produto> fabrica = Produto::new;     // construtor
Supplier<List<String>> novaLista = ArrayList::new;

São quatro formas:

A terceira forma confunde na primeira vez: Produto::nome não diz de qual produto, porque o produto é o primeiro parâmetro da função. Quando a lambda chama um método existente sem fazer mais nada, a referência costuma ser mais legível. Quando há alguma lógica a mais, a lambda é a escolha certa.

Com lambdas e referências, a ordenação de "Ordem e Critério" fica como prometido:

turma.sort(Comparator.comparingDouble(Aluno::nota).reversed().thenComparing(Aluno::nome));

Comparator.comparingDouble recebe uma função que extrai a chave de comparação (a nota) e devolve um comparador pronto. thenComparing desempata pela outra chave. A linha se lê como a especificação: "compare pela nota, do maior para o menor, e depois pelo nome".

Compondo funções

Como as funções agora são valores, elas podem ser combinadas por métodos default das próprias interfaces:

Predicate<String> comecaComA = s -> s.startsWith("A");
Predicate<String> curto = s -> s.length() <= 4;
Predicate<String> filtro = comecaComA.and(curto.negate());

for (String nome : List.of("Ana", "Antônio", "Bruno", "Alice")) {
    IO.println(nome + " -> " + filtro.test(nome));
}

Ana -> false
Antônio -> true
Bruno -> false
Alice -> true

Predicate tem and, or e negate. Function tem andThen, que aplica a outra função depois, e compose, que a aplica antes:

Function<Integer, Integer> dobro = x -> x * 2;
Function<Integer, Integer> maisTres = x -> x + 3;
IO.println(dobro.andThen(maisTres).apply(5));    // 13: (5 * 2) + 3
IO.println(dobro.compose(maisTres).apply(5));    // 16: (5 + 3) * 2

Function<String, String> normalizar = ((Function<String, String>) String::strip)
        .andThen(String::toLowerCase)
        .andThen(s -> s.replace(' ', '-'));
IO.println(normalizar.apply("  Curso de Java  "));   // curso-de-java

(O cast na primeira referência dá ao compilador o tipo alvo, que ele precisa para chamar andThen. Na prática, declara-se primeiro uma variável Function<String, String> limpar = String::strip; e compõe-se a partir dela.) Composição transforma pequenas funções testáveis em processamentos maiores, sem nenhum laço, e é exatamente o que as streams da próxima aula fazem em grande escala.

Métodos que recebem e devolvem funções

Um método pode receber um comportamento como parâmetro, o que permite separar o que fazer de quantas vezes ou quando fazer:

void repetir(int vezes, Runnable acao) {
    for (int i = 0; i < vezes; i++) {
        acao.run();
    }
}

repetir(3, () -> IO.print("eco "));   // eco eco eco

Runnable é uma interface funcional antiga, dos tempos do Java 1.0, sem parâmetros e sem retorno, que você vai reencontrar na Fase 7, onde representa uma tarefa a ser executada por uma thread. E um método pode devolver um comportamento, fabricando funções sob medida:

IntUnaryOperator multiplicador(int fator) {
    return x -> x * fator;
}

IntUnaryOperator triplo = multiplicador(3);
IntUnaryOperator dezVezes = multiplicador(10);
IO.println(triplo.applyAsInt(7) + " " + dezVezes.applyAsInt(7));   // 21 70

Cada chamada a multiplicador devolve uma função diferente, que lembra o fator com que foi criada. Uma função que carrega consigo valores do contexto em que nasceu se chama closure.

A regra das variáveis efetivamente finais

Como as classes anônimas de "Ordem e Critério", uma lambda só pode usar variáveis locais que sejam final ou efetivamente finais:

int contador = 0;
List.of(1, 2, 3).forEach(x -> contador++);

Captura.java:6: error: local variables referenced from a lambda expression must be final or effectively final

A lambda recebe uma cópia do valor da variável no momento da criação. Se a variável pudesse mudar, a cópia e a original divergiriam, e o código seria enganoso. Há ainda um motivo mais sério: uma lambda pode ser executada em outra thread, depois que o método que a criou já terminou, e aí a variável local original nem existe mais. Contornar a regra com truques, como guardar o contador num array de um elemento (int[] contador = {0}), funciona, mas é um sinal de que o estilo está errado. Na próxima aula, contar elementos vai ser uma única operação, sem nenhuma variável mutável.

Uma diferença entre lambdas e classes anônimas: dentro de uma lambda, this se refere ao objeto que contém o código, como se a lambda fosse parte do método. Dentro de uma classe anônima, this é o próprio objeto anônimo. As lambdas não criam um escopo novo, e isso as torna mais previsíveis.

Novidades nas coleções

Com lambdas, as coleções ganharam métodos que recebem comportamentos. Eles cumprem as promessas de "Listas, Conjuntos e Mapas":

List<Integer> valores = new ArrayList<>(List.of(3, -1, 4, -5, 9, 2));
valores.removeIf(v -> v < 0);             // [3, 4, 9, 2]
valores.replaceAll(v -> v * 10);          // [30, 40, 90, 20]
valores.forEach(v -> IO.print(v + " "));  // 30 40 90 20

removeIf substitui o laço com iterador daquela aula, sem risco de ConcurrentModificationException. Nos mapas, dois métodos eliminam os padrões mais repetitivos:

Map<String, Integer> contagem = new TreeMap<>();
for (String palavra : texto.split(" ")) {
    contagem.merge(palavra, 1, Integer::sum);
}

Map<String, List<String>> agenda = new TreeMap<>();
agenda.computeIfAbsent("Ana", k -> new ArrayList<>()).add("81 9999-0000");
agenda.computeIfAbsent("Ana", k -> new ArrayList<>()).add("81 3333-0000");
agenda.computeIfAbsent("Bia", k -> new ArrayList<>()).add("11 98888-0000");
IO.println(agenda);   // {Ana=[81 9999-0000, 81 3333-0000], Bia=[11 98888-0000]}

agenda.forEach((nome, tels) -> IO.println(nome + ": " + tels.size() + " telefone(s)"));

merge(chave, valor, funcao) grava o valor se a chave não existe, e senão combina o valor antigo com o novo usando a função. Com Integer::sum, é um contador em uma linha. computeIfAbsent(chave, funcao) devolve o valor da chave e, se ela não existe, cria o valor com a função e o guarda antes de devolver. É o padrão da agenda do exercício 5 de "Listas, Conjuntos e Mapas", que tinha cinco linhas e agora tem uma.

O que acontece por baixo

Uma lambda não é uma classe anônima disfarçada. Compilando um programa com uma lambda e uma classe anônima, só a anônima gera um arquivo $1.class. A lambda vira um método privado da própria classe, chamado algo como lambda$main$0, e o ponto em que ela é criada usa uma instrução de bytecode chamada invokedynamic:

0: invokedynamic #7,  0    // InvokeDynamic #0:apply:()Ljava/util/function/Function;
private static java.lang.Integer lambda$main$0(java.lang.String);

Na primeira execução dessa instrução, a JVM decide como construir o objeto que implementa a interface funcional e reaproveita essa decisão nas vezes seguintes. Lambdas que não capturam nenhuma variável costumam virar um único objeto, reutilizado. Para o programador, a consequência prática é que lambdas são baratas, e o JIT consegue otimizá-las tão bem quanto chamadas diretas de métodos.

O que as lambdas não resolvem bem

Uma limitação real: as interfaces de java.util.function não declaram exceções verificadas. Uma lambda que chama um método que lança uma não compila:

Function<Path, String> ler = p -> Files.readString(p);

Checked.java:3: error: unreported exception IOException; must be caught or declared to be thrown

As saídas são tratar a exceção dentro da lambda, com try/catch, convertendo-a numa exceção não verificada com a original como causa, como ensinou "Quando o Contrato se Quebra", ou declarar uma interface funcional própria cujo método declare throws IOException. É uma das razões do debate sobre exceções verificadas, e uma das razões pelas quais a biblioteca de arquivos ganhou a classe UncheckedIOException.

As lambdas trouxeram o comportamento como valor, mas os programas ainda percorrem as coleções com laços: para filtrar, para transformar, para somar, para agrupar. Com funções como valores, uma pergunta se torna natural: e se, em vez de escrever o laço, você descrevesse o resultado, como "os alunos aprovados, ordenados por nota, só os nomes", e deixasse a biblioteca decidir como percorrer? É isso que a API de Streams faz.

Fontes e leituras recomendadas

• Oracle, The Java Tutorials, "Lambda Expressions" e "Method References": https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html. A introdução oficial, que também parte das classes anônimas.
• Documentação do pacote java.util.function (Java SE 25): https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/function/package-summary.html. Todas as interfaces funcionais da biblioteca, incluindo as especializações para primitivos.
• Brian Goetz, "State of the Lambda" (2013): https://cr.openjdk.org/~briangoetz/lambda/lambda-state-final.html. O documento do arquiteto da linguagem sobre o projeto das lambdas: tipo alvo, captura de variáveis, referências a métodos e a escolha de não criar tipos de função.
• Brian Goetz, "Translation of Lambda Expressions" (2012): https://cr.openjdk.org/~briangoetz/lambda/lambda-translation.html. Como as lambdas são compiladas com invokedynamic, e por que essa escolha foi melhor do que gerar classes anônimas.
• Joshua Bloch, Effective Java, 3ª edição, itens 42 a 44: "Prefer lambdas to anonymous classes", "Prefer method references to lambdas" e "Favor the use of standard functional interfaces".

Exercícios

Exercício 1

Reescreva cada trecho usando lambda ou referência a método, o que for mais legível:

Comparator<String> porTamanho = new Comparator<String>() {
    public int compare(String a, String b) { return Integer.compare(a.length(), b.length()); }
};
Runnable saudacao = new Runnable() {
    public void run() { IO.println("Olá!"); }
};
Function<String, String> maiusculas = new Function<String, String>() {
    public String apply(String s) { return s.toUpperCase(); }
};

Comparator<String> porTamanho = Comparator.comparingInt(String::length);
Runnable saudacao = () -> IO.println("Olá!");
Function<String, String> maiusculas = String::toUpperCase;

Exercício 2

Diga qual interface de java.util.function combina com cada lambda: (a) p -> p.preco() > 100, recebendo um Produto; (b) () -> new ArrayList<String>(); (c) s -> IO.println(s); (d) (a, b) -> a + b, com dois Integer; (e) s -> s.length(), recebendo um String.

Exercício 3

Explique o que contagem.merge(palavra, 1, Integer::sum) faz em cada uma das duas situações possíveis, e compare com a versão da aula "Listas, Conjuntos e Mapas".

Exercício 4

O código abaixo não compila. Explique por quê e reescreva-o sem nenhuma variável mutável capturada.

List<String> nomes = List.of("Ana", "Bruno", "Alice", "Carla");
int quantosComA = 0;
nomes.forEach(n -> {
    if (n.startsWith("A")) {
        quantosComA++;
    }
});

int quantosComA = 0;
for (String n : nomes) {
    if (n.startsWith("A")) {
        quantosComA++;
    }
}

Exercício 5

Escreva um método UnaryOperator<String> encadear(List<UnaryOperator<String>> etapas) que devolva uma única função que aplique todas as etapas em ordem. Teste com as etapas "remover espaços das pontas", "converter para minúsculas" e "trocar sequências de espaços por hífen".

UnaryOperator<String> encadear(List<UnaryOperator<String>> etapas) {
    UnaryOperator<String> resultado = s -> s;
    for (UnaryOperator<String> etapa : etapas) {
        UnaryOperator<String> anterior = resultado;
        resultado = s -> etapa.apply(anterior.apply(s));
    }
    return resultado;
}

void main() {
    var limpeza = encadear(List.of(
        String::strip,
        String::toLowerCase,
        s -> s.replaceAll("\\s+", "-")));
    IO.println(limpeza.apply("  Olá Mundo   Java "));   // olá-mundo-java
}