Dica de Código: Expressões Lambda em Java

As expressões lambda são uma característica poderosa do Java que permite criar instâncias de interfaces funcionais de forma concisa e simplificada. Além disso, podemos reduzir a quantidade de código necessário para criar e implementar interfaces funcionais utilizando expressões lambda.

Neste artigo, vamos explorar o uso de expressões lambda no contexto das interfaces funcionais em Java. Vamos começar definindo uma interface funcional e mostrando como criar uma instância dessa interface utilizando uma classe anônima. Em seguida, iremos introduzir as expressões lambda como uma forma mais simplificada de alcançar o mesmo resultado.

Interfaces Funcionais

Curso Java - Stream API

Conhecer o curso

Antes de mergulharmos nas expressões lambda, precisamos entender o conceito de interfaces funcionais. Primeiramente, uma interface funcional é aquela que contém apenas um método abstrato. Portanto, ao utilizar expressões lambda, podemos reduzir a quantidade de código necessário para criar e implementar interfaces funcionais.

Vamos considerar a interface funcional Calculadora como exemplo. Essa interface possui apenas um método abstrato chamado calcular. Além disso, é recomendado utilizar a anotação @FunctionalInterface para identificar claramente uma interface funcional.

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

public class ExemploLambda {

    public static void main(String[] args) {
        /*
         * Podemos criar uma instância da interface 
         * Calculadora usando uma classe anônima.
         */
        Calculadora somar = new Calculadora() {
            @Override
            public int calcular(int a, int b) {
                return a + b;
            }
        };

        /*
         * Usa a instância da interface Calculadora 
         * para calcular a soma de dois números.
         */
        int resultado = somar.calcular(2, 3);
        System.out.println(resultado); // Imprime 5
    }
}

Expressões Lambda

Agora que compreendemos o conceito de interfaces funcionais, podemos explorar as expressões lambda. De fato, as expressões lambda permitem criar instâncias de interfaces funcionais de maneira concisa e legível. Consequentemente, tornam o código mais limpo e de fácil compreensão.

Para simplificar o código do exemplo anterior, podemos substituir a implementação da interface funcional Calculadora utilizando uma expressão lambda. Nesse caso, a expressão lambda será equivalente à classe anônima criada anteriormente.

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

public class ExemploLambda {

    public static void main(String[] args) {
        Calculadora somar = (int a, int b) -> a + b;

        /*
         * Usa a instância da interface Calculadora
         * para calcular a soma de dois números
         */
        int resultado = somar.calcular(2, 3);
        System.out.println(resultado); // Imprime 5
    }
}

Em suma, uma expressão lambda consiste em três partes:

1. A lista de parâmetros;
2. O símbolo ->;
3. O corpo da expressão.

No exemplo acima, utilizamos (int a, int b) como lista de parâmetros e a + b como corpo da expressão.

Exemplos de Uso

As expressões lambda são especialmente úteis ao trabalhar com coleções, em conjunto com a Stream API. A seguir, apresentamos exemplos práticos do uso de expressões lambda para filtrar uma lista de strings e transformar uma lista de números.

Para filtrar uma lista de strings, podemos utilizar uma expressão lambda como predicado no método filter da Stream API.

import java.util.List;
import java.util.stream.Collectors;

public class ExemploLambda {

    public static void main(String[] args) {
        // Cria uma lista de strings
        List<String> nomes = List.of(
            "Maria",
            "João",
            "Pedro",
            "Ana",
            "Lucas"
        );

        // Filtra os nomes que começam com a letra "M"
        List<String> nomesComM = nomes.stream()
            .filter(nome -> nome.startsWith("M"))
            .collect(Collectors.toList());

        System.out.println(nomesComM); // Imprime [Maria]
    }
}

Nesse caso, a expressão lambda nome -> nome.startsWith("M") é passada como parâmetro para o método filter. Essa expressão é equivalente a uma instância da interface funcional Predicate, que contém o método abstrato test que recebe um parâmetro e retorna um boolean.

Outro exemplo de uso de expressões lambda é para transformar cada elemento de uma lista de números em seu quadrado, utilizando o método map da Stream API.

import java.util.List;
import java.util.stream.Collectors;

public class ExemploLambda {

    public static void main(String[] args) {
        // Cria uma lista de números inteiros
        List<Integer> numeros = List.of(1, 2, 3, 4, 5);

        // Transforma cada número em seu quadrado usando uma expressão lambda
        List<Integer> quadrados = numeros.stream()
            .map(numero -> numero * numero)
            .collect(Collectors.toList());

        System.out.println(quadrados); // Imprime [1, 4, 9, 16, 25]
    }
}

Nesse exemplo, a expressão lambda numero -> numero * numero é utilizada como parâmetro para o método map. Essa expressão é equivalente a uma instância da interface funcional Function, que contém o método abstrato apply que recebe um parâmetro e retorna um valor.

Conclusão

Em conclusão, as expressões lambda são uma ferramenta poderosa para tornar o código Java mais conciso e legível. Além disso, elas permitem criar instâncias de interfaces funcionais de forma simplificada, facilitando o trabalho com coleções e a Stream API. Com o conhecimento adquirido neste artigo, você estará preparado para utilizar expressões lambda em seus projetos Java, melhorando a qualidade e eficiência do seu código.