Streams em Java

Inicie um pipeline a partir de uma lista com stream(), mantenha ou altere elementos e imprima. Em Pipe.java, mantenha a classe pública Pipe, importe java.util.ArrayList, guarde "oak" e "pine", e chame names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n));. Compile com javac Pipe.java e execute java Pipe. A tela deve mostrar oak. Uma segunda demo usa map para a tela mostrar OAK, depois PINE. Deixe Records opcional para a próxima página. Esta lição é pipeline stream, não forEach simples na lista e não demo Generics get(0).

Filtrar uma palavra que combina

Abra Pipe.java. Mantenha o nome da classe pública Pipe. Apague demos lambda Cue sobrando, impressões Generics Bin sobrando, execuções Program Arguments Flag sobrando e prompts Scanner Box se enterrarem a história dos streams. O programa não deve esperar digitação nem exigir palavras de lançamento.
Adicione o import no topo:
import java.util.ArrayList;
Dentro de Pipe.main, monte uma lista tipada com duas palavras e inicie um stream que mantém palavras começando com o:
ArrayList<String> names = new ArrayList<>();
names.add("oak");
names.add("pine");
names.stream().filter(n -> n.startsWith("o")).forEach(n -> System.out.println(n));
stream() abre o pipeline. filter mantém elementos cuja lambda retorna true. forEach imprime cada elemento mantido. "oak" começa com o. "pine" não. A tela mostra oak.

Na pasta que contém Pipe.java, execute javac Pipe.java. Quando chaves e ponto-e-vírgula combinam, javac não escreve linha própria. Depois execute java Pipe — não java Pipe.java. Mantenha uma classe pública para o nome combinar com Pipe.
Percorra a execução uma vez. Java começa em Pipe.main. A lista tem "oak" e "pine". stream() começa. filter mantém "oak". forEach imprime oak. Nada imprime as duas palavras. Nada chama só names.forEach sem stream(). Nada lê args[0].
Diga a regra de iniciante vendo a tela: stream() abre o cano; filter escolhe; forEach termina com efeito colateral de impressão. Não invente demos Records nesta página. Records espera a próxima lição opcional. Não remova stream() esperando que filter prenda na lista nesta forma didática.
Se ainda vir oak depois pine de um arquivo Cue forEach sobrando, mude para Pipe e mantenha o passo filter. Se javac rejeitar stream, confirme que o tipo da lista é ArrayList e a chamada é names.stream().

Mapear cada palavra para maiúsculas

Mantenha a mesma classe pública Pipe. Mude o pipeline para transformar cada palavra em vez de filtrar:
names.stream().map(n -> n.toUpperCase()).forEach(n -> System.out.println(n));
Mantenha "oak" e "pine" na lista. Compile de novo com javac Pipe.java e execute java Pipe. A tela mostra OAK, depois PINE. map retorna um valor novo para cada elemento. forEach imprime esses valores em ordem.

Percorra a execução uma vez. O primeiro valor mapeado é OAK. O segundo é PINE. Mantenha as duas demos como duas formas didáticas. Primeiro prove que filter mantém uma palavra. Depois prove que map muda cada palavra. Ambas compartilham import, lista tipada, stream() e forEach terminal.
Se encadear filter e map em experimentos depois, a ordem importa. Esta página mantém um passo intermediário por demo para a tela ficar fácil de ler.

Hábitos de pipeline

Mantenha os passos em ordem enquanto pratica.

Streams não é só Lambda e não é Records

Lambda ensinou forEach direto na lista. Streams coloca stream() primeiro para você filter ou map antes do forEach final. Records vai introduzir um tipo de dados compacto numa página opcional depois. Não misture os três papéis num arquivo iniciante hoje.
oak mantido por filter ainda é elemento da lista fluindo no pipeline. Não é args[0] do Flag. Quando um arquivo Cue sobrando imprime cada elemento sem filter, deixe como histórico e mantenha a linha stream().filter do Pipe.
Sem stream(), as chamadas filter e map desta página não são a forma didática. Sem forEach terminal, o pipeline não imprime. Mantenha as duas pontas do cano juntas enquanto pratica cada demo. Mantenha sintaxe Records fora desta página até essa lição, mesmo se já viu manchete sobre tipos compactos no caminho opcional.

Checagens da pasta antes de Records

Liste a pasta após compilação bem-sucedida. Você deve ver Pipe.java e Pipe.class juntos. Edite a fonte, salve, execute javac Pipe.java, depois java Pipe. Um .class antigo pode mostrar tela filter velha se pular compile depois de mudar para map.
Se javac reclamar de classes públicas duplicadas, mantenha só Pipe pública. Se a tela mostrar oak e pine na demo filter, o teste startsWith("o") pode faltar — restaure a lambda filter. Se nada imprimir, confirme que add rodou antes de stream().
Não cole o forEach só da lista do Cue como substituto do pipeline inteiro nesta página. Não cole get(0) do Bin no Pipe. O trabalho streams opcional é stream mais um passo intermediário mais forEach.

Antes de Records opcional

Você pode manter classe pública Pipe, importar ArrayList, adicionar "oak" e "pine", chamar names.stream().filter(n -> n.startsWith("o")).forEach(...), ver oak, depois chamar names.stream().map(n -> n.toUpperCase()).forEach(...), ver OAK depois PINE. Compile com javac Pipe.java e execute java Pipe. A tabela separa início, filter, map e fim. A próxima página opcional é Records.
Mantenha as demos Pipe para um par streams claro. Mantenha arquivos lambda Cue fora desta página ao praticar pipelines. Mantenha arquivos Generics Bin fora desta página ao praticar pipelines. Mantenha trabalho Records fora desta página até essa lição. Esses hábitos são o checkpoint antes de seguir. Quando a tela filter mostrar oak ou a tela map mostrar OAK depois PINE, Streams fez o trabalho desta lição e você está pronto para Records se continuar o caminho opcional.
Uma última passada na pasta: um Pipe público, import presente, ArrayList<String> tipada, stream() antes de filter ou map, forEach terminal, sem espera Scanner, sem palavras de lançamento. Execute javac Pipe.java e java Pipe mais uma vez na demo aberta. Se a tela ainda mostrar oak ou OAK depois PINE, a forma Streams está sólida e o curso pode ir para Records opcional na próxima página. Prefira um hábito pipeline claro por leitura para cada passagem ensinar o mesmo mapa.