Java Academy · Lektion

Primitive Streams erzeugen

iterate und generate

Primitive Streams erzeugen 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.

Unendliche Streams benötigen Begrenzungen

iterate und generate erzeugen potenziell unendliche Streams. Sie müssen limit (oder ein Predicate) hinzufügen, um sie endlich zu machen.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

Mit einem Seed iterieren

iterate(seed, next) beginnt beim Seed und wendet die Funktion wiederholt auf den vorherigen Wert an.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(2, n -> n * 2)
            .limit(5)
            .forEach(System.out::println);
    }
}

Mit einem Prädikat iterieren

Das iterate(seed, hasNext, next) mit drei Argumenten endet automatisch, sobald das Prädikat false ergibt – ähnlich wie eine funktionale for-Schleife.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n <= 100, n -> n * 3)
            .forEach(System.out::println);
    }
}

Mit einem Supplier generieren

generate nimmt einen IntSupplier entgegen, der jedes Element unabhängig erzeugt, ohne vom vorherigen Wert abzuhängen.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.generate(() -> 7)
            .limit(3)
            .forEach(System.out::println);
    }
}

Zufallszahlen generieren

Ein generate-Supplier kann eine Zufallsquelle aufrufen. Hier ist jedes Element ein unabhängiger Würfelwurf.

import java.util.Random;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Random rnd = new Random(42);
        IntStream.generate(() -> rnd.nextInt(6) + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

iterate und generate im Vergleich

Der entscheidende Unterschied:

iterate: Jeder Wert wird aus dem vorherigen abgeleitet (Sequenzen).
generate: Jeder Wert wird unabhängig erzeugt (Konstanten, Zufallswerte).

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.iterate(1, n -> n + 1).limit(10).sum();
        System.out.println(sum);
    }
}

Generierte Streams aggregieren

Sobald sie begrenzt sind, unterstützen generierte Streams alle üblichen Aggregationen.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.iterate(0, n -> n + 2)
            .limit(50)
            .filter(n -> n % 3 == 0)
            .count();
        System.out.println(count);
    }
}

Fibonacci mit iterate in einem Objekt-Stream

Für zustandsbehaftete Sequenzen wie Fibonacci verwenden Sie Stream.iterate über ein Array-Paar und bilden anschließend wieder auf int ab.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.iterate(new int[]{0, 1}, p -> new int[]{p[1], p[0] + p[1]})
            .limit(8)
            .mapToInt(p -> p[0])
            .forEach(System.out::println);
    }
}

Ein Array aus einem Generator erstellen

Kombinieren Sie einen Generator mit toArray, um prozedural ein primitives Array zu erstellen.

import java.util.Arrays;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] squares = IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .map(n -> n * n)
            .toArray();
        System.out.println(Arrays.toString(squares));
    }
}

Verzögerte Auswertung spart Arbeit

Streams werden verzögert ausgewertet: Mit limit werden selbst aus einer unendlichen Quelle nur die benötigten Elemente generiert.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int first = IntStream.iterate(10, n -> n + 10)
            .filter(n -> n > 25)
            .findFirst()
            .getAsInt();
        System.out.println(first);
    }
}

Bevorzugen Sie die Prädikatform

Das prädikatbasierte iterate ist oft verständlicher als iterate(...).limit(...), weil die Abbruchbedingung direkt zur Generierungslogik gehört.

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long product = LongStream.iterate(1, n -> n <= 5, n -> n + 1)
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Kurze Prüfung

Was passiert, wenn Sie generate ohne limit und anschließend eine Terminaloperation wie forEach aufrufen?

Zusammenfassung

Sie haben primitive Streams generiert:

iterate leitet jeden Wert aus dem vorherigen ab.
generate erzeugt Werte unabhängig aus einem Supplier.
Beide sind unendlich; begrenzen Sie sie mit limit oder der Prädikatform von iterate.
Dank der verzögerten Auswertung werden nur benötigte Elemente berechnet.

Häufig gestellte Fragen

Ist die Lektion „Primitive Streams erzeugen“ kostenlos?

Ja — der vollständige Text von „Primitive Streams erzeugen“ 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 „Primitive Streams erzeugen“?

iterate und generate 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 „Primitive Streams erzeugen“?

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

← Zurück zu Java Academy