Streams em Java: filter, map, collect e reduce explicados

Pipelines em vez de laços

Um stream é um pipeline para processar uma sequência de valores. Você parte de uma fonte - normalmente uma coleção - encadeia operações como "mantenha apenas estes", "transforme cada um", "ordene-os" e termina coletando o resultado. Em vez de escrever um laço com uma lista temporária e um if dentro, você descreve o que quer e deixa o stream percorrer tudo.

Agora que você tem lambdas, os streams se encaixam: cada operação recebe uma lambda (ou uma referência a método) que descreve o trabalho para um único elemento.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Ada", "Boris", "Chen", "Dmitri");

        List<String> result = names.stream()
            .filter(name -> name.length() > 3)   // mantém nomes com mais de 3 caracteres
            .map(String::toUpperCase)            // transforma cada um
            .collect(Collectors.toList());       // reúne em uma nova lista

        System.out.println(result);
    }
}

Leia de cima para baixo: pegue os nomes, mantenha os longos, deixe em maiúsculas, colete em uma lista. A lista original names nunca é modificada - um stream produz um novo resultado e deixa a fonte intacta.

A anatomia de um stream

Todo pipeline tem três partes:

• Uma fonte - list.stream(), Arrays.stream(array) ou Stream.of(a, b, c).
• Zero ou mais operações intermediárias - filter, map, sorted, distinct, limit. Cada uma retorna outro stream, então você pode encadeá-las.
• Exatamente uma operação terminal - collect, count, forEach, reduce, findFirst. Ela dispara o trabalho e produz um resultado (ou um efeito colateral).

Essa divisão importa por causa de uma regra que surpreende todo mundo no início.

Operações intermediárias são preguiçosas

As operações intermediárias não fazem nada por conta própria. Elas apenas registram o que deveria acontecer. O pipeline só roda quando uma operação terminal pede um resultado.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            });
        // Sem operação terminal -> nada é impresso.

        System.out.println("Done, but nothing was mapped.");
    }
}

Execute: a lambda do map nunca roda. Adicione uma operação terminal e toda a cadeia ganha vida:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        List<Integer> doubled = nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            })
            .collect(Collectors.toList());   // terminal -> agora roda

        System.out.println(doubled);
    }
}

Essa preguiça não é uma esquisitice para combater - ela permite que o stream funda operações e pule o trabalho de que não precisa. Mas significa que um pipeline sem operação terminal não faz nada, o que é um bug comum do tipo "por que nada está acontecendo?".

filter e map: manter e transformar

Esses dois carregam quase todo o peso. filter recebe um Predicate (uma lambda que retorna boolean) e mantém os elementos que passam. map recebe uma Function e substitui cada elemento pelo resultado de aplicá-la.

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

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "fig", "banana", "kiwi", "cherry");

        List<Integer> lengths = words.stream()
            .filter(w -> w.length() > 3)   // descarta "fig" e "kiwi"
            .map(String::length)           // transforma cada palavra em seu comprimento
            .collect(Collectors.toList());

        System.out.println(lengths);   // [5, 6, 6]
    }
}

Note que map pode mudar o tipo do elemento: aqui um stream de String se torna um stream de Integer. O String::length é uma referência a método - uma forma abreviada da lambda w -> w.length().

Operações terminais produzem um resultado

Depois de moldar o stream, uma operação terminal o transforma em algo concreto:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);

        long bigCount = nums.stream()
            .filter(n -> n > 3)
            .count();                       // quantos passaram?

        boolean anyEven = nums.stream()
            .anyMatch(n -> n % 2 == 0);     // existe pelo menos um par?

        System.out.println("Big numbers: " + bigCount);
        System.out.println("Any even? " + anyEven);
    }
}

Operações terminais comuns: collect (reunir em uma lista/conjunto/mapa), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max e reduce. Depois que uma terminal roda, o stream fica consumido - você não pode reutilizá-lo. Chame list.stream() de novo para obter um pipeline novo.

Coletando resultados

collect com Collectors é o burro de carga para construir um resultado. O mais comum é Collectors.toList():

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

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("ada", "boris", "chen");

        // Junta em uma única string
        String joined = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println(joined);   // ADA, BORIS, CHEN
    }
}

Collectors também oferece toSet(), joining(...), groupingBy(...) e counting(). No Java 16 e posteriores você pode substituir collect(Collectors.toList()) pelo mais curto .toList() (ele retorna uma lista imutável):

List<String> result = names.stream().map(String::toUpperCase).toList();

sorted, distinct e limit

Essas operações intermediárias remodelam o stream antes de você coletar:

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(5, 3, 8, 3, 1, 9, 5, 2);

        List<Integer> top3 = nums.stream()
            .distinct()                 // remove duplicatas
            .sorted((a, b) -> b - a)    // decrescente
            .limit(3)                   // pega os três primeiros
            .collect(Collectors.toList());

        System.out.println(top3);   // [9, 8, 5]
    }
}

sorted() sem argumento usa a ordenação natural; passe um Comparator (aqui uma lambda) para uma ordem personalizada. Comparator.reverseOrder() é a forma mais limpa de ordenar em ordem decrescente.

reduce: dobrar um stream em um único valor

Quando você precisa combinar todos os elementos em um único resultado - uma soma, um produto, a string mais longa - reduce é a ferramenta geral. Você fornece um valor inicial e uma função que mescla dois valores:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);

        int sum = nums.stream()
            .reduce(0, (a, b) -> a + b);   // começa em 0, vai somando

        int product = nums.stream()
            .reduce(1, (a, b) -> a * b);   // começa em 1, vai multiplicando

        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

Para somas e médias simples, os streams especializados são mais claros: nums.stream().mapToInt(Integer::intValue).sum(). Recorra a reduce quando não houver um agregador pronto.

Streams não substituem todo laço

Streams brilham quando você está transformando uma coleção em um resultado. Eles não são automaticamente mais rápidos que um laço, e ficam desajeitados quando você precisa alterar estado externo ou sair antecipadamente de formas complicadas. Uma boa regra: se o pipeline se lê como uma frase clara, use um stream; se você está recorrendo a um contador compartilhado ou a um index, um laço for comum é honesto e está ótimo.

Lembre-se também de que um stream é de uso único. Isto lança uma exceção:

Stream<String> s = names.stream();
s.forEach(System.out::println);
s.count();   // IllegalStateException: stream has already been operated upon

Próximo: Optional

Várias operações terminais dos streams - findFirst, min, max, reduce sem identidade - podem não encontrar nada, então não retornam um valor cru. Elas retornam um Optional, o contêiner do Java para "talvez um valor, talvez nada", que finalmente oferece uma alternativa limpa a retornar null. Essa é a próxima página.