Programação Funcional no Java

A programação funcional é um paradigma que trata funções como cidadãos de primeira classe e incentiva a composição e a imutabilidade. Introduzido no Java 8, esse paradigma ganhou destaque com as expressões lambda, a API de Streams e o suporte a métodos de alta ordem.

Neste artigo, exploraremos como aplicar programação funcional em Java usando as expressões lambda e a Stream API, criando código mais conciso, legível e eficiente.

O Que São Expressões Lambda?

As expressões lambda permitem que você trate funções como valores. Elas são uma maneira concisa de implementar interfaces funcionais, simplificando o código e eliminando a necessidade de classes anônimas verbosas.

Sintaxe Geral

(parametros) -> { corpo }

Exemplo Simples

Sem lambda:

Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Olá, Lambda!");
    }
};

Com lambda:

Runnable r = () -> System.out.println("Olá, Lambda!");

Trabalhando com a Stream API

A Stream API é uma ferramenta poderosa para processar coleções de dados de maneira funcional. Ela permite operações como filtragem, mapeamento, redução e muito mais, usando pipelines declarativos.

Operações em Streams

As operações em Streams podem ser classificadas como:

1. Intermediárias: Retornam uma nova Stream e são "preguiçosas", como filter, map e sorted.
2. Terminais: Consomem a Stream e retornam um valor final, como forEach, collect e reduce.

Exemplo:

List<String> nomes = Arrays.asList("Ana", "Bruno", "Carlos");
nomes.stream()
    .filter(nome -> nome.startsWith("A"))
    .map(String::toUpperCase)
    .forEach(System.out::println);

Saída:

ANA

Operações Comuns em Streams

1. Filtragem

Retorna apenas os elementos que atendem a uma condição.

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> pares = numeros.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());
System.out.println(pares); // [2, 4]

2. Mapeamento

Transforma cada elemento em outro valor.

List<String> palavras = Arrays.asList("java", "lambda", "stream");
List<Integer> tamanhos = palavras.stream()
    .map(String::length)
    .collect(Collectors.toList());
System.out.println(tamanhos); // [4, 6, 6]

3. Redução

Combina os elementos em um único valor.

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
int soma = numeros.stream().reduce(0, Integer::sum);
System.out.println(soma); // 15

Interfaces Funcionais

Uma interface funcional é uma interface com apenas um método abstrato. Elas podem ser usadas como tipos para expressões lambda.

Exemplo de Interface Funcional

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

public class Main {
    public static void main(String[] args) {
        Operacao soma = (a, b) -> a + b;
        System.out.println(soma.calcular(5, 3)); // 8
    }
}

Boas Práticas na Programação Funcional

1. Prefira Imutabilidade: Evite modificar coleções ou variáveis dentro de lambdas.
2. Mantenha Lambdas Simples: Não sobrecarregue lambdas com lógica complexa; delegue a métodos auxiliares, se necessário.
3. Use Métodos de Referência: Sempre que possível, substitua lambdas por referências de métodos (String::toUpperCase).
4. Cuidado com Streams Paralelas: Embora úteis para ganho de desempenho, avalie se o paralelismo é realmente necessário.

A programação funcional no Java, com o uso de expressões lambda e a Stream API, traz uma abordagem moderna e eficiente para lidar com coleções e lógica funcional. Ao adotar práticas funcionais, você pode criar códigos mais concisos, legíveis e fáceis de manter. Experimente esses conceitos em seus projetos e descubra como transformar sua maneira de programar!