Streams: Aprenda a Processar Dados de Forma Simples no Java

O uso de Streams no Java é uma maneira moderna e elegante de simplificar o processamento de dados. Introduzidas no Java 8, as streams permitem processar coleções de forma declarativa, utilizando operações como filtro, mapeamento e redução, sem a necessidade de loops explícitos. Aqui está uma visão geral de como simplificar o processamento de dados com streams:

Table of Contents

1. O que é uma Stream?

Uma Stream é uma sequência de elementos que suporta várias operações, podendo ser executadas de forma sequencial ou paralela. Ela não armazena dados, mas fornece um pipeline de operações sobre fontes de dados como listas, arrays, etc.

2. Operações de Stream

As operações com streams podem ser divididas em dois tipos:

Operações intermediárias: transformam uma stream em outra (ex: filter, map, distinct).
Operações terminais: produzem um resultado ou efeito colateral (ex: collect, forEach, reduce).

3. Como Funciona o Pipeline de Streams?

Uma pipeline de stream consiste em uma fonte de dados, uma sequência de operações intermediárias e uma operação terminal. As operações são preguiçosas (lazy), o que significa que só são executadas quando uma operação terminal é invocada.

4. Exemplos Práticos

4.1. Filtrando dados

Podemos usar o método filter para remover elementos que não atendem a uma condição.

List<String> nomes = Arrays.asList("Ana", "João", "Carlos", "Maria");
List<String> nomesComA = nomes.stream()
                              .filter(nome -> nome.startsWith("A"))
                              .collect(Collectors.toList());
System.out.println(nomesComA);  // Saída: [Ana]

List<String> nomes = Arrays.asList("Ana", "João", "Carlos", "Maria");

List<String> nomesComA = nomes.stream()

.filter(nome -> nome.startsWith("A"))

.collect(Collectors.toList());

System.out.println(nomesComA); // Saída: [Ana]

4.2. Mapeando dados

Com map, transformamos cada elemento de uma coleção.

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> numerosDobro = numeros.stream()
                                    .map(n -> n * 2)
                                    .collect(Collectors.toList());
System.out.println(numerosDobro);  // Saída: [2, 4, 6, 8, 10]

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

List<Integer> numerosDobro = numeros.stream()

.map(n -> n * 2)

.collect(Collectors.toList());

System.out.println(numerosDobro); // Saída: [2, 4, 6, 8, 10]

4.3. Reduzindo dados

O método reduce combina elementos da stream em um único valor.

List<Integer> numeros = Arrays.asList(1, 2, 3, 4, 5);
int soma = numeros.stream()
                  .reduce(0, (subtotal, n) -> subtotal + n);
System.out.println(soma);  // Saída: 15

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

int soma = numeros.stream()

.reduce(0, (subtotal, n) -> subtotal + n);

System.out.println(soma); // Saída: 15

4.4. Trabalhando com Strings

Podemos utilizar streams com strings para transformar e manipular texto.

String frase = "Aprender Java com Streams é incrível!";
List<String> palavras = Arrays.stream(frase.split(" "))
                              .filter(palavra -> palavra.length() > 3)
                              .collect(Collectors.toList());
System.out.println(palavras);  // Saída: [Aprender, Java, com, Streams, incrível!]

String frase = "Aprender Java com Streams é incrível!";

List<String> palavras = Arrays.stream(frase.split(" "))

.filter(palavra -> palavra.length() > 3)

.collect(Collectors.toList());

System.out.println(palavras); // Saída: [Aprender, Java, com, Streams, incrível!]

5. Benefícios de Usar Streams

Código mais legível: O código se torna mais expressivo e menos verboso, reduzindo a necessidade de loops aninhados.
Imutabilidade: Streams não modificam a coleção original, o que aumenta a segurança.
Paralelismo: As streams podem ser executadas em paralelo para melhor desempenho em grandes volumes de dados.

6. Streams Paralelas

Se você precisa de um melhor desempenho com grandes volumes de dados, pode transformar uma stream sequencial em uma paralela:

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

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

int soma = numeros.parallelStream()

.reduce(0, Integer::sum);

System.out.println(soma); // Saída: 15

Conclusão

No Java oferece uma maneira eficiente e declarativa de manipular coleções e dados, tornando o código mais conciso e legível. Elas são uma poderosa ferramenta para quem quer otimizar o processamento de dados em Java.