WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Numerische Operationen mit IntStream

Erzeuge Streams aus primitiven `int`-Werten und filtere sie. Lerne die Rückgabetypen und das Verhalten beim Zählen, Summieren und Mitteln leerer Streams kennen.

Version: Java SE 21

Syntax

import java.util.OptionalDouble;
import java.util.function.IntPredicate;
import java.util.stream.IntStream;

// IntStream method signatures
static IntStream of(int t)
static IntStream of(int... values)
IntStream filter(IntPredicate predicate)
long count()
int sum()
OptionalDouble average()

In Java SE 21 verarbeitet java.util.stream.IntStream primitive int-Werte statt Integer-Objekten. Die statische Fabrikmethode IntStream.of ist überladen: of(int) erzeugt einen sequenziellen Stream mit einem Element, of(int...) einen sequenziellen Stream in der Reihenfolge der übergebenen Werte. Die zweite Überladung akzeptiert auch ein int[] oder keine Argumente; ohne Argumente ist der Stream leer.

IntStream.filter(IntPredicate) ist eine verzögert ausgewertete Zwischenoperation. Der resultierende Stream enthält nur Elemente, für die das Prädikat true liefert. Das Prädikat darf weder die Quelle verändern noch von einem Zustand abhängen, der sich während der Verarbeitung ändern kann. In n -> n % 2 == 0 berechnet % den Rest bei der Division durch 2, und == 0 prüft, ob dieser Rest null ist.

Die Endoperationen haben unterschiedliche Rückgabetypen: IntStream.count() liefert die Anzahl als long, IntStream.sum() die Summe als int. Bei einem leeren Stream liefern beide null als Zahlenwert. Die Summe kann ohne Ausnahme den Wertebereich von int überschreiten; die Zuweisung des Ergebnisses an eine long-Variable verhindert den Überlauf nicht. IntStream.average() liefert das arithmetische Mittel in einem OptionalDouble, das bei einem leeren Stream leer ist. Mit orElse(...) legst du einen expliziten Ersatzwert fest.

Eine Endoperation verbraucht die Verarbeitungskette. Erzeuge für eine weitere unabhängige Berechnung mit denselben Daten einen neuen Stream aus der Quelle. Eine Wiederverwendung ist unzulässig und kann, wenn sie erkannt wird, zu einer IllegalStateException führen.

Beispiele

import java.util.OptionalDouble;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] values = {2, 3, 7, 10};

        long count = IntStream.of(values).count();
        int sum = IntStream.of(values).sum();
        OptionalDouble average = IntStream.of(values).average();
        int evenSum = IntStream.of(values).filter(n -> n % 2 == 0).sum();
        OptionalDouble negativeAverage = IntStream.of(values)
                .filter(n -> n < 0)
                .average();

        System.out.println("count = " + count);
        System.out.println("sum = " + sum);
        System.out.println("average = " + average.orElse(Double.NaN));
        System.out.println("even sum = " + evenSum);
        System.out.println("negative average = " + negativeAverage.orElse(Double.NaN));
    }
}

Ergebnis

count = 4
sum = 22
average = 5.5
even sum = 12
negative average = NaN

Jede Berechnung beginnt mit einem neuen `IntStream.of(values)`. Der Filter für gerade Zahlen behält `2` und `10`. Der Filter für negative Zahlen lässt nichts durch; `NaN` stammt daher aus dem expliziten Ersatzwert und nicht aus `average()`.

Zugehörige Lektionen

  • Java · Lektion 46 · Mittlere Stufe · Version: 2

Quellen