Oändliga strömmar med iterate och generate
Skapa oändliga strömmar med Stream.iterate och Stream.generate och använd sedan limit eller take-while för att stoppa dem.
Oändliga strömmar med iterate och generate är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad är oändliga strömmar?
Java-strömmar kan vara oändliga — de producerar element vid behov utan något slut. De måste avslutas med en begränsande operation (limit, takeWhile, findFirst och så vidare) för att undvika att köras för alltid.
Stream.iterate: sekvenser med startvärde
Stream.iterate(seed, f) genererar en oändlig ström genom att upprepade gånger tillämpa f på det föregående värdet. Det första elementet är startvärdet.
// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println);iterate med Predicate (Java 9+)
Stream.iterate(seed, predicate, f) lägger till ett stoppvillkor — ungefär som en for-loop med ett villkor. Strömmen stoppas när predikatet är falskt.
// 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: tillståndslös generator
Stream.generate(Supplier) anropar leverantören för varje element. Leverantören kan vara tillståndslös (slumptal) eller tillståndsberoende (med en extern räknare).
// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
.limit(5)
.forEach(System.out::println);Generera UUID:er
Använd generate med UUID::randomUUID för att skapa en ström med unika identifierare för generering av batch-ID:n.
List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
.limit(100)
.collect(Collectors.toList());
System.out.println(ids.size()); // 100Fibonacci med iterate
Generera Fibonacci-tal med hjälp av ett tillståndspar. Java 9:s iterate med två argument gör detta elegant.
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 och dropWhile (Java 9+)
takeWhile(predicate) hämtar element så länge predikatet är uppfyllt och stoppar sedan. dropWhile hoppar över element tills predikatet blir falskt och hämtar därefter resten.
// 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 9Oändliga strömmar för upprepade avfrågningar
Modellera en avfrågningsloop med generate: generera kontrollresultat, använd takeWhile så länge villkoret inte är uppfyllt och hämta sedan den första lyckade träffen.
Optional<String> result = Stream.generate(() -> checkJobStatus(jobId))
.takeWhile(status -> status.equals("PENDING"))
.findFirst();
// When job completes, takeWhile stops and findFirst gets "DONE"IntStream.range och rangeClosed
För ändliga heltalssekvenser är IntStream.range(start, end) och rangeClosed(start, end) effektivare än iterate.
// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500LongStream.iterate för långa sekvenser
Använd LongStream.iterate för långa sekvenser för att undvika omkostnaden för autoboxning i Stream<Long>.
long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
.filter(n -> isPrime(n))
.limit(1000)
.sum();Oändliga strömmar är lata
Oändliga strömmar förberäknar inte element. Varje element genereras först när terminaloperationen efterfrågar det. Denna lathet gör oändliga strömmar praktiskt användbara.
Snabb kontroll
Vilken stoppmekanism krävs när du arbetar med en oändlig ström?
Sammanfattning
iterate(seed, f) för sekvenser och generate(supplier) för oberoende elementgenerering. Lägg alltid till en kortslutande terminaloperation (limit, takeWhile, findFirst). Oändliga strömmar är lata — de materialiseras först vid behov.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”Oändliga strömmar med iterate och generate” gratis?
Ja – hela texten till ”Oändliga strömmar med iterate och generate” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Oändliga strömmar med iterate och generate”?
Skapa oändliga strömmar med Stream.iterate och Stream.generate och använd sedan limit eller take-while för att stoppa dem. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.
Hur lång tid tar lektionen ”Oändliga strömmar med iterate och generate”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- flatMap för nästlade samlingar
- Parallella strömmar: prestanda och fallgropar
- Spliterator: uppdelning för parallellism
- Oändliga strömmar med iterate och generate