Java Academy · Lektion

IntStream und LongStream

Boxing in Streams vermeiden

IntStream und LongStream ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Warum primitive Streams existieren

Stream<Integer> verpackt jedes Element in ein Integer-Objekt. IntStream, LongStream und DoubleStream arbeiten mit unverpackten primitiven Werten, um den Boxing-Overhead zu vermeiden.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.of(1, 2, 3, 4).sum();
        System.out.println(sum);
    }
}

Einen IntStream erstellen

Verwenden Sie IntStream.of für explizite Werte oder Arrays.stream mit einem int[].

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

public class Main {
    public static void main(String[] args) {
        int[] data = {10, 20, 30};
        IntStream s = Arrays.stream(data);
        System.out.println(s.max().getAsInt());
    }
}

LongStream für große Zahlen

LongStream funktioniert ähnlich wie IntStream, arbeitet jedoch mit long-Werten und verhindert Überläufe bei großen Summen.

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long total = LongStream.of(1_000_000_000L, 2_000_000_000L).sum();
        System.out.println(total);
    }
}

Spezialisierte Terminaloperationen

Primitive Streams bieten numerische Methoden, die Objekt-Streams nicht besitzen: sum, min, max, average.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream nums = IntStream.of(4, 8, 15, 16, 23, 42);
        System.out.println(nums.average().getAsDouble());
    }
}

Ergebnisse vom Typ OptionalInt

min und max geben OptionalInt zurück, weil der Stream leer sein kann. Verwenden Sie getAsInt oder orElse.

import java.util.OptionalInt;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        OptionalInt result = IntStream.empty().max();
        System.out.println(result.orElse(-1));
    }
}

map bleibt primitiv

map für einen IntStream nimmt einen IntUnaryOperator entgegen und gibt einen weiteren IntStream zurück, sodass kein Boxing stattfindet.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sumOfSquares = IntStream.of(1, 2, 3)
            .map(n -> n * n)
            .sum();
        System.out.println(sumOfSquares);
    }
}

filter für primitive Streams

filter nimmt ein IntPredicate entgegen und behält passende primitive Werte.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long evens = IntStream.of(1, 2, 3, 4, 5, 6)
            .filter(n -> n % 2 == 0)
            .count();
        System.out.println(evens);
    }
}

reduce für IntStream

reduce fasst den Stream mithilfe eines IntBinaryOperator zusammen. Mit einem Identitätswert gibt die Methode direkt einen int zurück.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int product = IntStream.rangeClosed(1, 5)
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

forEach für primitive Werte

forEach nimmt einen IntConsumer entgegen und vermeidet damit ebenfalls Boxing.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.of(7, 8, 9).forEach(n -> System.out.println(n));
    }
}

In ein Array sammeln

toArray gibt ein primitives int[] zurück, das natürliche Gegenstück zu einem IntStream.

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

public class Main {
    public static void main(String[] args) {
        int[] doubled = IntStream.of(1, 2, 3).map(n -> n * 2).toArray();
        System.out.println(Arrays.toString(doubled));
    }
}

Zwischen Int und Long konvertieren

IntStream.asLongStream erweitert primitive Werte auf long, ohne Boxing zu verwenden.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long sum = IntStream.of(1, 2, 3).asLongStream().sum();
        System.out.println(sum);
    }
}

Schnelltest

Was ist der wichtigste Grund, IntStream statt Stream<Integer> zu verwenden?

Zusammenfassung

Sie haben primitive Streams verwendet, um Boxing zu vermeiden:

IntStream und LongStream enthalten unverpackte primitive Werte.
Sie bieten numerische Terminaloperationen: sum, min, max, average.
min und max geben OptionalInt zurück.
map, filter, reduce und toArray bleiben alle primitiv.

Häufig gestellte Fragen

Ist die Lektion „IntStream und LongStream“ kostenlos?

Ja — der vollständige Text von „IntStream und LongStream“ 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 „IntStream und LongStream“?

Boxing in Streams vermeiden 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 1 von 4.

Wie lange dauert die Lektion „IntStream und LongStream“?

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