Streams infinitos com iterate e generate
Crie streams infinitos com Stream.iterate e Stream.generate e depois use limit ou take-while para interrompê-los.
Streams infinitos com iterate e generate é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.
O que são fluxos infinitos?
Os fluxos Java podem ser infinitos: eles produzem elementos sob demanda, sem um fim. É necessário encerrá-los com uma operação limitadora (limit, takeWhile, findFirst etc.) para evitar que sejam executados indefinidamente.
Stream.iterate: sequências com semente
Stream.iterate(seed, f) gera um fluxo infinito aplicando repetidamente f ao valor anterior. O primeiro elemento é a semente.
// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println);iterate com predicado (Java 9+)
Stream.iterate(seed, predicate, f) adiciona uma condição de parada, como um laço for com uma condição. O fluxo para quando o predicado é falso.
// Equivalent to: for (int i = 1; i <= 100; i *= 2)
Stream.iterate(1, n -> n <= 100, n -> n * 2)
.forEach(System.out::println); // 1 2 4 8 16 32 64Stream.generate: gerador sem estado
Stream.generate(Supplier) chama o fornecedor para cada elemento. O fornecedor pode não ter estado (números aleatórios) ou ter estado (usando um contador externo).
// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
.limit(5)
.forEach(System.out::println);Gerando UUIDs
Use generate com UUID::randomUUID para criar um fluxo de identificadores exclusivos para gerar IDs em lote.
List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
.limit(100)
.collect(Collectors.toList());
System.out.println(ids.size()); // 100Fibonacci com iterate
Gere números de Fibonacci usando um estado composto por um par. O iterate de dois argumentos do Java 9 torna isso elegante.
Stream.iterate(new long[]{0, 1}, p -> new long[]{p[1], p[0]+p[1]})
.limit(10)
.map(p -> p[0])
.forEach(System.out::println); // 0 1 1 2 3 5 8 13 21 34takeWhile e dropWhile (Java 9+)
takeWhile(predicate) obtém elementos enquanto o predicado for satisfeito e então para. dropWhile ignora elementos até que o predicado deixe de ser satisfeito e então obtém o restante.
// takeWhile stops at the first element where predicate is false:
Stream.iterate(1, n -> n + 1)
.takeWhile(n -> n < 10)
.forEach(System.out::println); // 1 2 3 4 5 6 7 8 9Fluxos infinitos para consultas periódicas de novas tentativas
Modele um laço de consulta periódica com generate: gere resultados de verificação, use takeWhile enquanto a condição não for satisfeita e então obtenha o primeiro sucesso.
Optional<String> result = Stream.generate(() -> checkJobStatus(jobId))
.takeWhile(status -> status.equals("PENDING"))
.findFirst();
// When job completes, takeWhile stops and findFirst gets "DONE"IntStream.range e rangeClosed
Para sequências inteiras finitas, IntStream.range(start, end) e rangeClosed(start, end) são mais eficientes que iterate.
// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500LongStream.iterate para sequências longas
Use LongStream.iterate para sequências longas e evite o custo da conversão automática de tipos de Stream<Long>.
long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
.filter(n -> isPrime(n))
.limit(1000)
.sum();Os fluxos infinitos são avaliados sob demanda
Os fluxos infinitos não calculam os elementos antecipadamente. Cada elemento é gerado somente quando a operação terminal o solicita. Essa avaliação sob demanda torna os fluxos infinitos práticos.
Verificação rápida
Qual mecanismo de parada é necessário ao trabalhar com um fluxo infinito?
Recapitulação
iterate(seed, f) para sequências, generate(supplier) para geração independente de elementos. Sempre adicione uma operação terminal de curto-circuito (limit, takeWhile, findFirst). Os fluxos infinitos são avaliados sob demanda: só são gerados quando necessário.
Perguntas Frequentes
A aula “Streams infinitos com iterate e generate” é grátis?
Sim — o texto completo de “Streams infinitos com iterate e generate” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.
O que vou aprender em “Streams infinitos com iterate e generate”?
Crie streams infinitos com Stream.iterate e Stream.generate e depois use limit ou take-while para interrompê-los. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Java Academy?
Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Streams infinitos com iterate e generate”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Java Academy?
Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- flatMap para coleções aninhadas
- Streams paralelos: desempenho e armadilhas
- Spliterator: divisão para paralelismo
- Streams infinitos com iterate e generate