Introdução à Stream API em Java

A partir da versão 8 do JDK, o Java introduziu uma nova API chamada Stream API. Seu principal objetivo é simplificar o trabalho com sequências de dados, facilitando operações como filtragem, ordenação e outras manipulações. Toda a funcionalidade desta API está concentrada no pacote java.util.stream.

O conceito central da Stream API é o fluxo de dados (stream). É importante notar que o termo "fluxo" é bastante utilizado em programação. No contexto da Stream API, um fluxo representa um canal por onde os dados de uma fonte são transportados. Essa fonte pode ser uma coleção, um array ou até mesmo um arquivo.

Uma das características marcantes da Stream API é o uso de expressões lambda, que permitem escrever o código de forma muito mais concisa e declarativa.

Em outras tecnologias, encontramos conceitos semelhantes. Na linguagem C#, por exemplo, a tecnologia LINQ (Language Integrated Query) possui uma funcionalidade análoga à Stream API.

Processamento de Dados Antes e Depois da Stream API

Para ilustrar a diferença, considere a tarefa de contar a quantidade de números maiores que zero em um array. Antes do JDK 8, a abordagem comum seria utilizar um laço de repetição.

int[] numbers = {-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5};
int count = 0;
for (int i : numbers) {
    if (i > 0) {
        count++;
    }
}
System.out.println(count); // Saída: 5

Com a Stream API, a mesma lógica pode ser expressa de forma mais direta e compacta.

import java.util.stream.IntStream;

public class Main {
  public static void main(String args[]) {
    long count = IntStream.of(-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5)
                        .filter(w -> w > 0)
                        .count();

    System.out.println(count); // Saída: 5
  }
}

Em vez de um laço de repetição e estruturas condicionais, é possível encadear uma sequência de métodos que descrevem as operações a serem executadas.

Operações Intermediárias e Terminais

Ao trabalhar com a Stream API, é fundamental entender que as operações são divididas em duas categorias: intermediárias (intermediate) e terminais (terminal).

Operações intermediárias retornam um novo fluxo transformado. No exemplo anterior, o método filter recebe um fluxo de números e retorna um novo fluxo contendo apenas os números maiores que zero. É possível aplicar outras operações intermediárias em sequência.

As operações terminais, por sua vez, produzem um resultado concreto ou um efeito colateral. No exemplo, o método count() é uma operação terminal que retorna a quantidade de elementos no fluxo. Após a chamada de uma operação terminal, o fluxo é consumido e não pode mais ser utilizado.

Uma característica importante é que os cálculos nas operações intermediárias só são executados quando uma operação terminal é chamada. Esse comportamento é conhecido como avaliação preguiçosa (lazy evaluation). Isso significa que, no exemplo acima, nenhum número é efetivamente filtrado até que o método count() seja chamado para solicitar o resultado final.

A Base da Stream API: A Interface BaseStream

A base da Stream API é a interface BaseStream. Esta interface serve como a fundação comum para todos os tipos de fluxos, garantindo um conjunto básico de comportamentos.

Sua definição é:

interface BaseStream<T, S extends BaseStream<T, S>>

Nesta definição, T representa o tipo dos elementos no fluxo, enquanto S representa o tipo do próprio fluxo.

A partir de BaseStream, derivam-se interfaces mais específicas para diferentes tipos de dados:

Stream<T>: Para fluxos de objetos de qualquer tipo de referência.
IntStream: Para fluxos de dados do tipo primitivo int.
DoubleStream: Para fluxos de dados do tipo primitivo double.
LongStream: Para fluxos de dados do tipo primitivo long.

Ao trabalhar com tipos primitivos, é mais eficiente utilizar as interfaces especializadas (IntStream, DoubleStream, LongStream), pois elas evitam o custo de conversão (boxing/unboxing) entre tipos primitivos e seus objetos wrapper, otimizando o desempenho. Na maioria dos casos que envolvem objetos complexos, a interface Stream<T> é a mais adequada.

Principais Operações da Interface Stream

A interface Stream<T> oferece um rico conjunto de métodos. Para facilitar o entendimento, podemos agrupá-los por sua finalidade.

Filtragem e Fatiamento (Operações Intermediárias)

Essas operações restringem o número de elementos no fluxo.

filter(Predicate<? super T> predicate): Retorna um fluxo contendo apenas os elementos que correspondem à condição.
distinct(): Retorna um fluxo com elementos únicos (remove duplicatas).
limit(long maxSize): Retorna um fluxo truncado com no máximo maxSize elementos.
skip(long n): Descarta os primeiros n elementos e retorna um fluxo com o restante.
takeWhile(Predicate<? super T> predicate): Retorna os elementos do início do fluxo enquanto a condição for verdadeira.
dropWhile(Predicate<? super T> predicate): Descarta os elementos do início enquanto a condição for verdadeira e retorna o restante.

Mapeamento e Transformação (Operações Intermediárias)

Essas operações transformam cada elemento do fluxo.

<R> Stream<R> map(Function<? super T,? extends R> mapper): Transforma cada elemento de tipo T para um tipo R.
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper): Transforma cada elemento em um novo fluxo e depois unifica todos os fluxos gerados em um único fluxo.

Ordenação (Operação Intermediária)

sorted(): Retorna um fluxo com os elementos ordenados em sua ordem natural.
sorted(Comparator<? super T> comparator): Retorna um fluxo com os elementos ordenados de acordo com o comparador fornecido.

Verificação (Operações Terminais)

Essas operações verificam se os elementos do fluxo atendem a uma condição e retornam um boolean.

anyMatch(Predicate<? super T> predicate): Retorna true se pelo menos um elemento corresponder à condição.
allMatch(Predicate<? super T> predicate): Retorna true se todos os elementos corresponderem à condição.
noneMatch(Predicate<? super T> predicate): Retorna true se nenhum elemento corresponder à condição.

Busca (Operações Terminais)

Essas operações encontram um elemento no fluxo.

findFirst(): Retorna o primeiro elemento do fluxo em um Optional.
findAny(): Retorna qualquer elemento do fluxo em um Optional.

Redução e Coleta (Operações Terminais)

Essas operações processam todos os elementos para produzir um único resultado.

count(): Retorna a quantidade de elementos no fluxo.
max(Comparator<? super T> comparator): Retorna o maior elemento em um Optional.
min(Comparator<? super T> comparator): Retorna o menor elemento em um Optional.
collect(Collector<? super T,A,R> collector): Transforma o fluxo em uma estrutura de dados, como uma List, Set ou Map.
toArray(): Retorna um array contendo os elementos do fluxo.

Diferenças entre Streams e Coleções

Apesar das semelhanças, é crucial entender as diferenças fundamentais entre fluxos e coleções.

Armazenamento: Coleções são estruturas de dados que armazenam elementos. Fluxos não armazenam elementos; eles são uma abstração que transporta dados de uma fonte através de um pipeline de operações.
Imutabilidade da Fonte: Operações em um fluxo não modificam sua fonte de dados original. Elas sempre geram um novo fluxo como resultado.
Avaliação Preguiçosa: Os fluxos utilizam a avaliação preguiçosa. As operações intermediárias apenas descrevem o processamento, que só é executado quando uma operação terminal é chamada.

Essas características tornam a Stream API uma ferramenta eficiente para processamento de dados em Java.

Resumo

A Stream API foi introduzida no Java 8 para processar sequências de dados de forma declarativa e funcional.
As operações são classificadas como intermediárias (que retornam um novo fluxo) ou terminais (que produzem um resultado final).
Os fluxos utilizam avaliação preguiçosa, adiando a execução das operações até que um resultado seja solicitado por uma operação terminal.
Diferente das coleções, os fluxos não armazenam dados e suas operações não modificam a fonte original dos dados.
Expressões lambda são a base para escrever operações concisas e legíveis com a Stream API.