Java Streams: filter, map, collect und reduce erklärt

Pipelines statt Schleifen

Ein Stream ist eine Pipeline zur Verarbeitung einer Folge von Werten. Du beginnst mit einer Quelle - üblicherweise einer Collection - verkettest Operationen wie „behalte nur diese", „transformiere jeden", „sortiere sie" und schließt ab, indem du das Ergebnis einsammelst. Statt eine Schleife mit einer temporären Liste und einem if darin zu schreiben, beschreibst du, was du willst, und überlässt dem Stream das Durchlaufen.

Jetzt, da du Lambdas hast, ergeben Streams Sinn: Jede Operation nimmt ein Lambda (oder eine Methodenreferenz) entgegen, das die Arbeit für ein einzelnes Element beschreibt.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Ada", "Boris", "Chen", "Dmitri");

        List<String> result = names.stream()
            .filter(name -> name.length() > 3)   // behalte Namen länger als 3 Zeichen
            .map(String::toUpperCase)            // transformiere jeden
            .collect(Collectors.toList());       // sammle in einer neuen Liste

        System.out.println(result);
    }
}

Lies es von oben nach unten: nimm die Namen, behalte die langen, wandle sie in Großbuchstaben um, sammle sie in einer Liste. Die ursprüngliche names-Liste wird nie verändert - ein Stream erzeugt ein neues Ergebnis und lässt die Quelle unangetastet.

Die Anatomie eines Streams

Jede Pipeline hat drei Teile:

• Eine Quelle - list.stream(), Arrays.stream(array) oder Stream.of(a, b, c).
• Null oder mehr Zwischenoperationen - filter, map, sorted, distinct, limit. Jede gibt einen weiteren Stream zurück, sodass du sie verketten kannst.
• Genau eine terminale Operation - collect, count, forEach, reduce, findFirst. Sie stößt die Arbeit an und erzeugt ein Ergebnis (oder einen Seiteneffekt).

Diese Aufteilung ist wichtig wegen einer Regel, die anfangs alle überrascht.

Zwischenoperationen sind verzögert (lazy)

Zwischenoperationen tun von sich aus nichts. Sie merken sich nur, was passieren soll. Die Pipeline läuft erst, wenn eine terminale Operation ein Ergebnis verlangt.

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            });
        // Keine terminale Operation -> es wird nichts ausgegeben.

        System.out.println("Done, but nothing was mapped.");
    }
}

Führe es aus: Das map-Lambda wird nie ausgeführt. Füge eine terminale Operation hinzu, und die ganze Kette erwacht zum Leben:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        List<Integer> doubled = nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            })
            .collect(Collectors.toList());   // terminal -> jetzt läuft es

        System.out.println(doubled);
    }
}

Diese Verzögerung ist keine Eigenheit, gegen die man ankämpfen müsste - sie erlaubt dem Stream, Operationen zu verschmelzen und unnötige Arbeit zu überspringen. Aber sie bedeutet, dass eine Pipeline ohne terminale Operation nichts tut, was ein häufiger „Warum passiert nichts?"-Bug ist.

filter und map: Behalten und Transformieren

Diese beiden tragen den Großteil der Last. filter nimmt einen Predicate (ein Lambda, das einen boolean zurückgibt) und behält die Elemente, die durchkommen. map nimmt eine Function und ersetzt jedes Element durch das Ergebnis ihrer Anwendung.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "fig", "banana", "kiwi", "cherry");

        List<Integer> lengths = words.stream()
            .filter(w -> w.length() > 3)   // verwirf "fig" und "kiwi"
            .map(String::length)           // verwandle jedes Wort in seine Länge
            .collect(Collectors.toList());

        System.out.println(lengths);   // [5, 6, 6]
    }
}

Beachte, dass map den Elementtyp ändern kann: Hier wird aus einem Stream von String ein Stream von Integer. Das String::length ist eine Methodenreferenz - eine Kurzform für das Lambda w -> w.length().

Terminale Operationen erzeugen ein Ergebnis

Sobald du den Stream geformt hast, verwandelt ihn eine terminale Operation in etwas Konkretes:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);

        long bigCount = nums.stream()
            .filter(n -> n > 3)
            .count();                       // wie viele sind durchgekommen?

        boolean anyEven = nums.stream()
            .anyMatch(n -> n % 2 == 0);     // ist mindestens eine gerade?

        System.out.println("Big numbers: " + bigCount);
        System.out.println("Any even? " + anyEven);
    }
}

Gängige Terminaloperationen: collect (in eine Liste/Menge/Map einsammeln), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max und reduce. Nachdem eine Terminaloperation gelaufen ist, ist der Stream verbraucht - du kannst ihn nicht wiederverwenden. Rufe list.stream() erneut auf, um eine frische Pipeline zu erhalten.

Ergebnisse einsammeln

collect mit Collectors ist das Arbeitspferd zum Aufbau eines Ergebnisses. Das gängigste ist Collectors.toList():

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("ada", "boris", "chen");

        // Zu einem einzigen String zusammenfügen
        String joined = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println(joined);   // ADA, BORIS, CHEN
    }
}

Collectors bietet dir außerdem toSet(), joining(...), groupingBy(...) und counting(). Ab Java 16 kannst du collect(Collectors.toList()) durch das kürzere .toList() ersetzen (es gibt eine nicht veränderbare Liste zurück):

List<String> result = names.stream().map(String::toUpperCase).toList();

sorted, distinct und limit

Diese Zwischenoperationen formen den Stream um, bevor du ihn einsammelst:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(5, 3, 8, 3, 1, 9, 5, 2);

        List<Integer> top3 = nums.stream()
            .distinct()                 // entferne Duplikate
            .sorted((a, b) -> b - a)    // absteigend
            .limit(3)                   // nimm die ersten drei
            .collect(Collectors.toList());

        System.out.println(top3);   // [9, 8, 5]
    }
}

sorted() ohne Argument verwendet die natürliche Ordnung; übergib einen Comparator (hier ein Lambda) für eine eigene Reihenfolge. Comparator.reverseOrder() ist die sauberere Art, absteigend zu sortieren.

reduce: Einen Stream zu einem einzigen Wert falten

Wenn du alle Elemente zu einem einzigen Ergebnis zusammenfassen musst - eine Summe, ein Produkt, der längste String - ist reduce das allgemeine Werkzeug. Du gibst ihm einen Startwert und eine Funktion, die zwei Werte zusammenführt:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);

        int sum = nums.stream()
            .reduce(0, (a, b) -> a + b);   // beginne bei 0, addiere weiter

        int product = nums.stream()
            .reduce(1, (a, b) -> a * b);   // beginne bei 1, multipliziere weiter

        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

Für einfache Summen und Durchschnitte sind die spezialisierten Streams klarer: nums.stream().mapToInt(Integer::intValue).sum(). Greife zu reduce, wenn es keinen fertigen Aggregator gibt.

Streams ersetzen nicht jede Schleife

Streams glänzen, wenn du eine Collection in ein Ergebnis transformierst. Sie sind nicht automatisch schneller als eine Schleife, und sie werden umständlich, wenn du externen Zustand verändern oder auf knifflige Weise vorzeitig abbrechen musst. Eine gute Regel: Liest sich die Pipeline wie ein klarer Satz, verwende einen Stream; greifst du nach einem gemeinsam genutzten Zähler oder einem index, ist eine einfache for-Schleife ehrlich und völlig in Ordnung.

Denk außerdem daran, dass ein Stream nur einmal verwendbar ist. Dies löst eine Exception aus:

Stream<String> s = names.stream();
s.forEach(System.out::println);
s.count();   // IllegalStateException: stream has already been operated upon

Als Nächstes: Optional

Mehrere Stream-Terminaloperationen - findFirst, min, max, reduce ohne Identität - finden möglicherweise nichts, also geben sie keinen nackten Wert zurück. Sie geben einen Optional zurück, Javas Container für „vielleicht ein Wert, vielleicht nichts", der dir endlich eine saubere Alternative dazu bietet, null zurückzugeben. Das ist die nächste Seite.