Expressões Lambdas em Java

Introdução

Desde o lançamento do Java 8, as expressões lambda se tornaram uma das adições mais revolucionárias à linguagem. Elas introduziram um estilo mais funcional de programação, permitindo escrever código mais conciso, legível e expressivo.

Antes das lambdas, era comum vermos implementações extensas de classes anônimas para realizar operações simples, especialmente em APIs como Collections e Streams. Com as lambdas, tarefas que antes exigiam várias linhas agora podem ser feitas em uma única.

Neste artigo, vamos entender o que são expressões lambda, como elas funcionam e como utilizá-las na prática com exemplos em Java.

O que são Expressões Lambda?

Uma expressão lambda é uma forma simplificada de implementar interfaces funcionais, ou seja, interfaces que possuem apenas um método abstrato.

A ideia é representar um comportamento (função) como um valor, permitindo que ele seja passado como argumento, armazenado em variáveis ou retornado por métodos.

A sintaxe básica é:

(parametros) -> { corpo }

1 – Lambda com um parâmetro e corpo simples:

x -> x * 2

2 – Lambda com múltiplos parâmetros:

(a, b) -> a + b

3 – Lambda com corpo composto (várias instruções):

(a, b) -> {
    int soma = a + b;
    return soma * 2;
}

Interfaces Funcionais e o Pacote “java.util.function“

As lambdas em Java funcionam apenas com interfaces funcionais, ou seja, aquelas que possuem exatamente um método abstrato.

Por exemplo:

@FunctionalInterface
interface Calculadora {
    int operar(int a, int b);
}

Essa interface pode ser utilizada com uma expressão lambda:

Calculadora soma = (a, b) -> a + b;
Calculadora multiplicacao = (a, b) -> a * b;

System.out.println(soma.operar(3, 4));          // Saída: 7
System.out.println(multiplicacao.operar(3, 4)); // Saída: 12

Além de criar suas próprias interfaces funcionais, o Java já fornece várias no pacote java.util.function, como:

Aplicações Práticas em Java

1 – Usando Lambda com “Collections”

Sem lambda:

List<String> nomes = Arrays.asList("Paulo", "Maria", "José");

for (String nome : nomes) {
    System.out.println(nome);
}

Com lambda:

nomes.forEach(nome -> System.out.println(nome));

Ou, ainda mais simples com referência de método:

nomes.forEach(System.out::println);

2 – Filtrando dados com “Stream” e “Predicate”

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5, 6);

numeros.stream()
       .filter(n -> n % 2 == 0)
       .forEach(System.out::println);

Saída:

2
4
6

3 – Transformando valores com “Function”

List<String> nomes = Arrays.asList("paulo", "maria", "joão");

List<String> nomesMaiusculos = nomes.stream()
                                    .map(nome -> nome.toUpperCase())
                                    .toList();

System.out.println(nomesMaiusculos);

Saída:

[PAULO, MARIA, JOÃO]

4 – Criando funções dinâmicas

Podemos criar e passar comportamentos como parâmetro, tornando o código mais reutilizável:

public static int executarOperacao(int a, int b, Calculadora calc) {
    return calc.operar(a, b);
}

public static void main(String[] args) {
    System.out.println(executarOperacao(5, 3, (x, y) -> x + y)); // 8
    System.out.println(executarOperacao(5, 3, (x, y) -> x * y)); // 15
}

Assim, temos os seguintes benefícios das Expressões Lambdas:

• Menos código repetitivo: elimina classes anônimas verbosas.
• Melhor legibilidade: foco no comportamento, não na estrutura.
• Integração com APIs modernas: especialmente “Stream API”
• Facilita programação funcional: traz o paradigma funcional ao Java.

Conclusão

As expressões lambda transformaram a forma como escrevemos código em Java. Elas permitem que os desenvolvedores expressem intenções de forma mais clara, reduzam a verbosidade e aproveitem recursos poderosos como Streams, Optionals e Interfaces Funcionais.

Dominar lambdas é essencial para qualquer desenvolvedor Java moderno, não apenas por produtividade, mas porque abre as portas para entender conceitos mais avançados de programação funcional e paradigmas reativos.

Se você ainda não utiliza lambdas no seu dia a dia, experimente refatorar pequenos trechos de código. Em pouco tempo, você perceberá como o seu código Java pode ficar mais limpo, moderno e elegante.