Stream infiniti con iterate e generate
Crei stream infiniti con Stream.iterate e Stream.generate, quindi utilizzi limit o take-while per interromperli.
Stream infiniti con iterate e generate è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.
Che cosa sono gli stream infiniti?
Gli stream Java possono essere infiniti: producono elementi su richiesta senza una fine. Devono terminare con un'operazione limitante (limit, takeWhile, findFirst ecc.) per evitare un'esecuzione indefinita.
Stream.iterate: sequenze con valore iniziale
Stream.iterate(seed, f) genera uno stream infinito applicando ripetutamente f al valore precedente. Il primo elemento è il valore iniziale.
// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println);iterate con Predicate (Java 9+)
Stream.iterate(seed, predicate, f) aggiunge una condizione di arresto, come un ciclo for con una condizione. Lo stream si arresta quando il predicato è 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: generatore senza stato
Stream.generate(Supplier) chiama il supplier per ogni elemento. Il supplier può essere senza stato (numeri casuali) oppure avere uno stato (ad esempio, usando un contatore esterno).
// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
.limit(5)
.forEach(System.out::println);Generare UUID
Usi generate con UUID::randomUUID per creare uno stream di identificatori univoci da usare nella generazione di ID in batch.
List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
.limit(100)
.collect(Collectors.toList());
System.out.println(ids.size()); // 100Numeri di Fibonacci con iterate
Generi i numeri di Fibonacci usando uno stato costituito da una coppia di valori. La versione a due argomenti di iterate introdotta in Java 9 rende questa soluzione 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) acquisisce gli elementi finché il predicato è soddisfatto, poi si arresta. dropWhile ignora gli elementi finché il predicato non è soddisfatto, poi acquisisce tutti i rimanenti.
// 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 9Stream infiniti per il polling dei tentativi
Modelli un ciclo di polling con generate: generi i risultati dei controlli, applichi takeWhile finché la condizione non è soddisfatta, quindi acquisisca il primo risultato positivo.
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
Per le sequenze intere finite, IntStream.range(start, end) e rangeClosed(start, end) sono più efficienti di iterate.
// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500LongStream.iterate per sequenze di long
Usi LongStream.iterate per le sequenze di long, così da evitare l'overhead dell'autoboxing di Stream<Long>.
long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
.filter(n -> isPrime(n))
.limit(1000)
.sum();Gli stream infiniti sono lazy
Gli stream infiniti non precalcolano gli elementi. Ogni elemento viene generato solo quando l'operazione terminale lo richiede. Questa valutazione lazy rende pratici gli stream infiniti.
Verifica rapida
Quale meccanismo di arresto è necessario quando si lavora con uno stream infinito?
Riepilogo
iterate(seed, f) per le sequenze, generate(supplier) per la generazione di elementi indipendenti. Aggiunga sempre un'operazione terminale short-circuit (limit, takeWhile, findFirst). Gli stream infiniti sono lazy: vengono materializzati solo su richiesta.
Impara Java con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 104
- Lezioni
- 374
Domande Frequenti
La lezione «Stream infiniti con iterate e generate» è gratuita?
Sì — il testo completo di «Stream infiniti con iterate e generate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.
Cosa imparerò in «Stream infiniti con iterate e generate»?
Crei stream infiniti con Stream.iterate e Stream.generate, quindi utilizzi limit o take-while per interromperli. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Java Academy?
Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Stream infiniti con iterate e generate»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Java Academy?
Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- flatMap per collezioni annidate
- Stream paralleli: prestazioni e insidie
- Spliterator: suddivisione per il parallelismo
- Stream infiniti con iterate e generate