0Pricing
Java Academy · Lektion

Unendliche Streams mit iterate und generate

Erstellen Sie mit Stream.iterate und Stream.generate unendliche Streams und beenden Sie sie anschließend mit limit oder take-while.

Unendliche Streams mit iterate und generate ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was sind unendliche Streams?

Java-Streams können unendlich sein – sie erzeugen Elemente bei Bedarf und haben kein Ende. Sie müssen mit einer begrenzenden Operation (limit, takeWhile, findFirst usw.) beendet werden, damit sie nicht unbegrenzt weiterlaufen.

Stream.iterate: Sequenzen mit Startwert

Stream.iterate(seed, f) erzeugt einen unendlichen Stream, indem f wiederholt auf den vorherigen Wert angewendet wird. Das erste Element ist der Startwert.

// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
    .limit(10)
    .forEach(System.out::println);

iterate mit Predicate (Java 9+)

Stream.iterate(seed, predicate, f) fügt eine Abbruchbedingung hinzu – ähnlich wie eine for-Schleife mit Bedingung. Der Stream endet, wenn das Predicate false ergibt.

// 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 64

Stream.generate: zustandsloser Generator

Stream.generate(Supplier) ruft den Supplier für jedes Element auf. Der Supplier kann zustandslos sein (Zufallszahlen) oder zustandsbehaftet (bei Verwendung eines externen Zählers).

// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
    .limit(5)
    .forEach(System.out::println);

UUIDs erzeugen

Verwenden Sie generate zusammen mit UUID::randomUUID, um einen Stream eindeutiger Bezeichner für die Erzeugung von Batch-IDs zu erstellen.

List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
    .limit(100)
    .collect(Collectors.toList());
System.out.println(ids.size()); // 100

Fibonacci mit iterate

Erzeugen Sie Fibonacci-Zahlen mithilfe eines Zustands, der aus einem Wertepaar besteht. Das zweistellige iterate von Java 9 macht dies besonders 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 34

takeWhile und dropWhile (Java 9+)

takeWhile(predicate) übernimmt Elemente, solange das Predicate true ergibt, und endet dann. dropWhile überspringt Elemente, bis das Predicate false ergibt, und übernimmt anschließend den Rest.

// 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 9

Unendliche Streams für Retry-Polling

Modellieren Sie eine Polling-Schleife mit generate: Erzeugen Sie Prüfergebnisse, verwenden Sie takeWhile, solange die Bedingung nicht erfüllt ist, und übernehmen Sie anschließend den ersten Erfolg.

Optional<String> result = Stream.generate(() -> checkJobStatus(jobId))
    .takeWhile(status -> status.equals("PENDING"))
    .findFirst();
// When job completes, takeWhile stops and findFirst gets "DONE"

IntStream.range und rangeClosed

Für endliche Ganzzahlsequenzen sind IntStream.range(start, end) und rangeClosed(start, end) effizienter als iterate.

// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500

LongStream.iterate für Long-Sequenzen

Verwenden Sie LongStream.iterate für Long-Sequenzen, um den Autoboxing-Overhead von Stream<Long> zu vermeiden.

long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
    .filter(n -> isPrime(n))
    .limit(1000)
    .sum();

Unendliche Streams sind lazy

Unendliche Streams berechnen Elemente nicht im Voraus. Jedes Element wird erst erzeugt, wenn die Terminaloperation es anfordert. Diese verzögerte Auswertung macht unendliche Streams praxistauglich.

Kurze Überprüfung

Welcher Mechanismus zum Beenden ist bei der Arbeit mit einem unendlichen Stream erforderlich?

Zusammenfassung

iterate(seed, f) für Sequenzen, generate(supplier) für die unabhängige Erzeugung von Elementen. Fügen Sie immer eine kurzschließende Terminaloperation (limit, takeWhile, findFirst) hinzu. Unendliche Streams sind lazy – sie werden erst bei Bedarf materialisiert.

Häufig gestellte Fragen

Ist die Lektion „Unendliche Streams mit iterate und generate“ kostenlos?

Ja — der vollständige Text von „Unendliche Streams mit iterate und generate“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Unendliche Streams mit iterate und generate“?

Erstellen Sie mit Stream.iterate und Stream.generate unendliche Streams und beenden Sie sie anschließend mit limit oder take-while. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Unendliche Streams mit iterate und generate“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. flatMap für verschachtelte Collections
  2. Parallele Streams: Leistung und Fallstricke
  3. Spliterator: Aufteilen für Parallelität
  4. Unendliche Streams mit iterate und generate
← Zurück zu Java Academy