Describe Stream interface and Stream pipeline

🔹 O que é Stream?

A Stream em Java é uma sequência de elementos computados sob demanda, usando operações funcionais como filter, map, limit, sorted, collect, etc.

⚠️ Importante:

  • Uma Stream não armazena dados
  • Ela não modifica a fonte original
  • Permite processamento paralelo ou sequencial
  • Usa lambda expressions

🧱 A Interface Stream<T>

Stream<String> stream = Stream.of("Ana", "Carlos", "João");

Ou a partir de uma coleção:

List<String> nomes = Arrays.asList("Ana", "Carlos");
Stream<String> stream = nomes.stream();

🧬 O que é uma Pipeline?

É a cadeia de operações realizadas em uma stream, composta por:

EtapaExemploTipo
Fonte (source)list.stream()Fonte
Intermediáriafilter(), map()Lazy
TerminalforEach(), collect()Executa

Exemplo de pipeline:

List<String> nomes = Arrays.asList("Lucas", "Ana", "Pedro");

nomes.stream()   // Fonte
  .filter(n -> n.startsWith("A")) // Intermediária
  .map(String::toUpperCase)       // Intermediária
  .forEach(System.out::println);  // Terminal

✔️ Imprime ANA

🚧 Diferenças entre Operações

✅ Intermediárias:

  • São lazy: não executam nada até chegar uma terminal
  • Podem ser encadeadas
  • Ex: map, filter, limit, sorted, distinct

✅ Terminais:

  • Executam o pipeline
  • Só pode haver uma por pipeline
  • Ex: forEach, collect, reduce, count, anyMatch

🧠 Dicas de Prova

  1. Stream não armazena dados, ela só processa.
  2. Operações intermediárias são lazy, só executam quando houver terminal.
  3. Não é possível reusar uma stream após terminal (IllegalStateException).
  4. map() transforma, filter() seleciona.
  5. Evite usar forEach() com lógica complexa; prefira collect.

✅ Exemplo de uso correto:

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

List<Integer> paresDobro = numeros.stream()
  .filter(n -> n % 2 == 0)
  .map(n -> n * 2)
  .collect(Collectors.toList());

System.out.println(paresDobro); 
// [4, 8]

🚫 Exemplo errado (reutilização de stream):

Stream<String> s = Stream.of("a", "b", "c");
s.forEach(System.out::println);
s.forEach(System.out::println); //❌
// IllegalStateException

🧪 Quiz (10 questões)

1. Qual método inicia uma Stream a partir de uma lista?

a) create()
b) stream()
c) generate()
d) collect()

2. O que a operação map() faz?

a) Filtra elementos
b) Transforma elementos
c) Remove elementos
d) Ordena elementos

3. O que ocorre se não houver operação terminal?

a) A stream não é criada
b) Nada é executado
c) A stream lança erro
d) Os dados são alterados

4. O que é filter()?

a) Transforma elementos
b) Seleciona com base em condição
c) Coleta elementos
d) Remove duplicatas

5. O que a operação collect() faz?

a) Finaliza a stream sem retornar dados
b) Conta os elementos
c) Coleta os dados em uma coleção
d) Reutiliza a stream

6. Qual das alternativas não é uma operação terminal?

a) forEach()
b) map()
c) reduce()
d) collect()

7. O que distinct() faz?

a) Remove elementos nulos
b) Remove duplicados
c) Ordena a lista
d) Reverte a lista

8. Qual operação transforma Stream<T> em Stream<R>?

a) filter()
b) forEach()
c) map()
d) peek()

9. count() retorna:

a) Uma stream
b) Um booleano
c) Um long
d) Um int

10. O que acontece se você tentar reusar uma stream?

a) Reinicia do zero
b) Duplica os elementos
c) Lança exceção
d) É ignorado

✅ Gabarito Comentado

  1. b – stream() cria uma stream a partir de uma lista.
  2. b – map() transforma elementos.
  3. b – Stream é lazy, nada é executado sem terminal.
  4. b – filter() filtra com base em uma condição booleana.
  5. c – collect() transforma a stream em uma coleção.
  6. b – map() é intermediária.
  7. b – distinct() remove duplicatas.
  8. c – map() transforma os tipos.
  9. c – count() retorna long.
  10. c – Stream só pode ser usada uma vez; reutilização gera erro.

📌 Resumo

  • A interface Stream permite operar de forma funcional sobre coleções.
  • Pipelines são compostas por: fonte → intermediárias → terminal.
  • Streams são lazy — só executam com terminal.
  • Métodos como map, filter, collect, reduce, forEach são essenciais.
  • Cuidado ao tentar reutilizar uma stream.

🎯 RESUMO VISUAL: Stream Interface e Pipeline em Java 8

  +----------------------+
  |     Fonte (Source)   |
  |----------------------|
  | list.stream()        |
  | Stream.of(...)       |
  +----------------------+
             |
             v
  +-------------------------+
  | Operações Intermediárias|
  |-------------------------|
  | filter()                |
  | map()                   |
  | sorted()                |
  | limit()                 |
  | distinct()              |
  +-------------------------+
     (Laziness - Encadeável)
             |
             v
  +----------------------+
  | Operação Terminal    |
  |----------------------|
  | forEach()            |
  | collect()            |
  | count()              |
  | reduce()             |
  +----------------------+
     (Executa o pipeline)

🔍 Exemplo prático do fluxo completo:

List<String> nomes = 
Arrays.asList("Ana", "Bruno", "Alice", "Carlos");

List<String> resultado = nomes.stream() // Fonte
  .filter(n -> n.startsWith("A"))      // Intermediária
  .map(String::toUpperCase)            // Intermediária
  .sorted()                            // Intermediária
  .collect(Collectors.toList());       // Terminal

Resultado: [ALICE, ANA]

✅ DICAS RÁPIDAS:

  • map() transforma valores → Stream<T> → Stream<R>
  • filter() seleciona com base em boolean
  • forEach() executa ação (mas não retorna nada)
  • collect() → transforma a stream em lista, set, string etc
  • Sem terminal, nada é executado
  • Stream não pode ser reutilizada

Deixe um comentário