Generics, Lambda-Ausdrücke und Streams in Java

Ein Container sollte dir sagen, was er enthält. Mit einem Typparameter kann eine einzige Klasse Strings, Zahlen oder eigene Objekte aufnehmen, und der Compiler prüft jede Verwendung, bevor das Programm läuft.

Gib einer Klasse einen Typparameter

In class Box<T> ist T ein Typparameter: ein Name für einen Typ, den der aufrufende Code angibt. Verwende ihn für Felder, Methodenparameter und Ergebnisse.

class Box<T> {
    private T value;

    public Box(T value) { this.value = value; }
    public T get() { return value; }
    public void set(T value) { this.value = value; }
}

Der Name des Konstruktors ist Box, ohne <T>. Die Deklaration hinter dem Klassennamen führt T für den Klassenrumpf ein. Erzeuge nun eine Box:

Box<String> b = new Box<>("tea");
String drink = b.get();
b.set("water");
System.out.println(drink);   // tea
System.out.println(b.get()); // water

String ist das Typargument. Für diese Variable gibt get() einen String zurück und set akzeptiert einen String. Beim Lesen ist keine explizite Typumwandlung nötig. Der versuchte Aufruf b.set(42) schlägt bei der Kompilierung fehl: „incompatible types: int cannot be converted to String“. Der Fehler markiert den falschen Schreibzugriff, bevor ein späterer Lesezugriff scheitern kann.

Warum nicht Object speichern?

Ein Object-Feld kann auf einen String oder eine Ganzzahl verweisen. Code, der einen String benötigt, muss das zurückgegebene Objekt explizit umwandeln. Wurde eine Ganzzahl gespeichert, wirft diese Typumwandlung zur Laufzeit eine ClassCastException. Eine Box<String> macht die beabsichtigte Beziehung zum Teil des deklarierten Typs.

Der Diamantoperator <> in new Box<>("tea") veranlasst den Compiler, die Typargumente abzuleiten. Die Prüfungen bleiben erhalten. Lässt du die spitzen Klammern ganz weg, wie in new Box("tea"), verwendest du einen rohen Typ und verlierst Prüfungen im Zusammenhang mit dem Typparameter. Weist du eine Konstruktion mit rohem Typ einer typisierten Variablen zu, entstehen Unchecked-Warnungen; die typisierte Variable setzt ihr eigenes deklariertes Typargument bei späteren Aufrufen weiterhin durch.

Verwende Wrapperklassen und mehrere Parameter

Ein Typargument muss ein Referenztyp sein. Verwende Box<Integer>, nicht Box<int>. Java verpackt das Literal 5 beim Erzeugen von new Box<Integer>(5) als Integer und entpackt es, wenn eine Rechnung einen int benötigt. Enthält n diese Box, ergibt int next = n.get() + 1; den Wert 6.

Zwei unabhängige Typen brauchen zwei Parameter. Ein Pair<K, V> kann ein Feld K first und ein Feld V second haben. Bei einem Pair<String, Integer> geben die Getter einen String und einen Integer zurück. Übliche Namen sind T für einen Typ, E für ein Element, K und V für Schlüssel und Wert und R für ein Ergebnis.

Verwende Typparameter in Interfaces

interface Container<T> {
    void put(T item);
    T take();
}

Eine Klasse kann die Wahl mit class Shelf<T> implements Container<T> offenhalten oder sie mit class NameList implements Container<String> festlegen. List<E> und Comparable<T> verwenden dieselbe Idee. Eine generische Klasse bleibt eine Klasse: Box<String> und Box<Integer> beschreiben unterschiedliche Verwendungen zur Kompilierzeit, keine zwei Klassendeklarationen. Sie können einander nicht zugewiesen werden, weil sie unterschiedliche Elementtypen zusichern.

Manche Operationen benötigen eine Typwahl für einen Aufruf, nicht für die Lebensdauer eines Objekts. Eine generische Methode führt ihren eigenen Typparameter ein und bewahrt eine Beziehung zwischen ihrer Eingabe und ihrem Ergebnis.

Deklariere den Typ vor dem Rückgabetyp

import java.util.List;

class Lists {
    public static <T> T last(List<T> list) {
        return list.get(list.size() - 1);
    }

    public static void main(String[] args) {
        int number = last(List.of(4, 8, 15));
        String word = Lists.<String>last(List.of("x", "y"));
        System.out.println(number); // 15
        System.out.println(word);   // y
    }
}

Lies die Deklaration in Teilen. static macht sie zu einer Klassenmethode. <T> führt einen Typparameter ein, der zur Methode gehört. Das nächste T ist der Rückgabetyp. List<T> besagt, dass die Eingabeliste und das Ergebnis denselben Elementtyp haben.

Für den ersten Aufruf leitet Java für T den Typ Integer ab. Das Ergebnis kann dann zu int entpackt werden. Im zweiten Aufruf ist <String> ein expliziter Typzeuge, der zwischen Punkt und Methodenname steht. Lists.last(...) würde hier denselben Typ ableiten. Ein Typzeuge benötigt vor dem Punkt einen Empfänger: einen Klassennamen für eine statische Methode oder ein Objekt wie this für eine Instanzmethode.

Diese Methode erwartet eine nicht leere Liste. Bei einer leeren Liste ist size() - 1 gleich -1, sodass get eine IndexOutOfBoundsException wirft. Generics prüfen Typen; sie beweisen nicht, dass ein Index existiert.

Verknüpfe mehrere Typen

Eine generische Methode kann mehrere Parameter einführen. Wenn eine Klasse Pair<K, V> mit Konstruktor und Gettern vorhanden ist, vertauscht diese vollständige Methode die Rollen:

static <K, V> Pair<V, K> swap(Pair<K, V> p) {
    return new Pair<>(p.getSecond(), p.getFirst());
}

Für ein Eingabepaar ("Ada", 36) vom Typ Pair<String, Integer> ist das Ergebnis (36, "Ada") vom Typ Pair<Integer, String>. Die Rückgabedeklaration drückt die Beziehung aus; ein Rückgabetyp Object würde sie verbergen und den aufrufenden Code zu einer expliziten Typumwandlung zwingen.

Eine Methode wie <T> int countEqual(List<T> list, T target) setzt ebenfalls Eingaben zueinander in Beziehung. Ihre Schleife kann jedes Element mit equals mit target vergleichen. Bei ["a", "b", "a", "c", "a"] und "a" ist die Anzahl 3. Die Typinferenz kann für Argumente einen gemeinsamen Obertyp wählen. Daher erzwingt die wiederholte Verwendung von T nicht immer, dass zwei Argumentausdrücke identische deklarierte Typen haben.

Entscheide, zu wem der Typparameter gehört

Eine Box<String> behält ihr Typargument für die Verwendung dieses Objekts. Lists.last wählt für jeden Aufruf ein neues Typargument. Eine gewöhnliche Hilfsklasse kann daher generische statische Methoden enthalten, ohne selbst generisch zu sein.

Eine statische Methode innerhalb von Box<T> kann das T der Klasse nicht verwenden: Die statische Methode gehört zur gemeinsam genutzten Klasse, nicht zu einer einzelnen Box. Deklariere einen eigenen Parameter, zum Beispiel static <E> Box<E> of(E value). Beginnt eine Methodendeklaration in einer gewöhnlichen Klasse mit static T first(...) ohne ein <T> für die Methode, meldet der Compiler, dass er T nicht finden kann. Ergänze die Deklaration vor dem Rückgabetyp; eine Änderung des Rückgabetyps zu Object würde die nützliche Beziehung aufgeben.

Ein unbeschränktes T unterstützt nur Operationen, die auf Object verfügbar sind. Typschranken ergänzen eine nützliche Zusicherung. Wildcards ermöglichen es einem Parameter, eine Familie generischer Typen zu akzeptieren, ohne vorzugeben, dass alle ihre Elementtypen identisch sind.

Fordere die benötigten Operationen

static <T extends Comparable<T>> T largest(List<T> list) {
    T best = list.get(0);
    for (T x : list) {
        if (x.compareTo(best) > 0) {
            best = x;
        }
    }
    return best;
}

Die Typschranke besagt, dass ein T sich mit einem anderen T vergleichen kann. Ausgehend von 3 ersetzt der Aufruf largest(List.of(3, 11, 7)) den bisher größten Wert durch 11 und lässt ihn bei 7 unverändert. Er gibt 11 zurück. Für ["pear", "apple", "plum"] ist "plum" in natürlicher Ordnung das größte Wort. Eine leere Liste scheitert bei get(0).

extends führt auch für Interfaces Typschranken ein. <T extends Number> macht doubleValue() verfügbar. Mehrere Typschranken verwenden &, wobei eine Klasse, falls vorhanden, an erster Stelle steht: <T extends Number & Comparable<T>>.

Warum List keine List ist

Integer erweitert Number, aber List<Integer> ist kein Untertyp von List<Number>. Generische Typen sind invariant. Wäre diese Zuweisung erlaubt, könnte Code über die Referenz vom Typ List<Number> ein Double hinzufügen; der ursprüngliche Besitzer würde es dann als Integer lesen. Ein Parameter vom Typ List<Number> akzeptiert Implementierungen wie ArrayList<Number>, lehnt aber List<Integer> ab.

Lies mit extends; füge mit super hinzu

static double sum(List<? extends Number> nums) {
    double total = 0;
    for (Number n : nums) total += n.doubleValue();
    return total;
}

static void addOneToThree(List<? super Integer> target) {
    target.add(1);
    target.add(2);
    target.add(3);
}

? extends Number bedeutet einen unbekannten Typ, der Number oder ein Untertyp davon ist. sum akzeptiert Listen von Ganzzahlen, Double-Werten oder Zahlen. Die Methode liest jedes Element als Number. sum(List.of(1.5, 2.5)) ergibt 4.0. Sie kann 3 nicht hinzufügen: Der unbekannte Elementtyp könnte Double sein. Die Typregeln erlauben das Hinzufügen von null, auch wenn eine bestimmte Liste dies zur Laufzeit ablehnen kann.

? super Integer bedeutet Integer oder einen Obertyp davon. Die zweite Methode kann Ganzzahlen zu einer modifizierbaren List<Integer>, List<Number> oder List<Object> hinzufügen. Ein über diesen Parameter gelesener Wert hat nur den Typ Object: Vorhandene Elemente könnten andere Zahlen oder Objekte sein.

Die Merkhilfe lautet PECS-Regel (Producer extends, consumer super). Sie beschreibt die Richtung der Elementübertragung, nicht ob die gesamte Collection unveränderlich ist. Beispielsweise kann das Entfernen von Elementen über eine Sicht mit extends weiterhin möglich sein.

Verwende einen benannten Typparameter, wenn ein Typ mehrere Positionen verknüpfen muss, insbesondere einen Eingabe- und einen Rückgabetyp. Verwende eine Wildcard, wenn nur ein Bereich akzeptierter Eingaben wichtig ist. Collections.copy liest aus List<? extends T> und schreibt in List<? super T>; das Ziel muss bereits genügend Positionen zum Ersetzen haben.

Generics geben dem Compiler mehr Informationen, als ein gewöhnlicher Klassentest zur Laufzeit hat. Wenn du verstehst, was nach der Kompilierung erhalten bleibt, erklären sich Warnungen zu rohen Typen und mehrere Operationen, die Java ablehnt.

Was die Typlöschung entfernt

Java prüft Typargumente und ersetzt dann Typparameter durch ihre Typschranken. Ein unbeschränktes T wird zu Object; ein T extends Number wird zu Number. Der Compiler fügt beim Lesen von Werten dort, wo nötig, explizite Typumwandlungen ein. Zur Laufzeit gibt es eine Klasse Box, daher gibt dies true aus:

System.out.println(
    new Box<String>("a").getClass()
    == new Box<Integer>(1).getClass()
);

Die Deklaration von Box kann die generische Klasse mit einem Wertefeld, einem Konstruktor und einem Getter sein. Beide Konstruktionen haben dieselbe Laufzeitklasse, obwohl ihre deklarierten Verwendungen unterschiedliche Prüfungen zur Kompilierzeit haben.

Operationen, die einen bekannten Laufzeittyp benötigen

Innerhalb einer generischen Klasse lässt sich new T() nicht kompilieren. Java weiß nicht, welchen Konstruktor der vom aufrufenden Code angegebene Typ hat. Nimm eine Fabrik entgegen, um den Wert zu erzeugen:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

class Factory {
    static <T> T create(Supplier<T> factory) {
        return factory.get();
    }

    public static void main(String[] args) {
        List<String> words = create(ArrayList::new);
        words.add("ready");
        System.out.println(words); // [ready]
    }
}

Der Supplier stellt das Verhalten zum Erzeugen bereit. Auch new T[10] und new List<Integer>[2] werden als generische Array-Erzeugung abgelehnt. Speichere eine Folge in einer ArrayList<T>, wenn du das Verhalten eines Arrays nicht benötigst.

Für ein Object obj kann obj instanceof List<String> das Element-Typargument nicht sicher prüfen. Verwende obj instanceof List<?>, um zu prüfen, ob es sich um eine Liste handelt, und behandle ihre Elemente dann als unbekannt. Dieser Test weist keinen String-Elementtyp nach.

Gemeinsame statische Mitglieder und Überladungen nach Typlöschung

Ein Feld wie static T shared kann das T der umgebenden Klasse nicht verwenden. Alle Parametrisierungen teilen sich das statische Mitglied. Eine statische Methode kann ein eigenes <E> einführen, unabhängig vom Klassenparameter.

Zwei Überladungen print(Set<String> s) und print(Set<Integer> s) können nicht in einer Klasse nebeneinander bestehen. Beide werden durch die Typlöschung zu einer Methode, die Set entgegennimmt, sodass ein Namenskonflikt entsteht. Gib den Operationen unterschiedliche Namen oder entwirf eine Methode, die das gemeinsame Verhalten behandelt.

Verfolge eine Unchecked-Warnung bis zum fehlerhaften Lesezugriff

List raw = new ArrayList();
raw.add("text");
raw.add(42);
for (Object value : raw) {
    String text = (String) value;
    System.out.println(text);
}

Dies gibt text aus, dann wirft die Typumwandlung von 42 eine ClassCastException. Die Deklaration mit rohem Typ kann eine Meldung zum rohen Typ auslösen; die Aufrufe zum Hinzufügen lösen Unchecked-Warnungen aus, weil generische Prüfungen umgangen wurden. Ersetzt du den rohen Typ durch List<String>, tritt der Fehler bei add(42) zur Kompilierzeit auf. Eine Unchecked-Warnung zeigt eine verlorene Garantie und das Risiko eines Fehlers bei der Ausführung an. Behebe die Verwendung des rohen Typs oder die unsichere Typumwandlung, statt anzunehmen, dass ein späterer Lesezugriff sicher sein wird.

Eine Methode kann eine Regel als Argument entgegennehmen. Ein Lambda-Ausdruck formuliert diese Regel dort, wo sie verwendet wird, während ein funktionales Interface Java mitteilt, welche Eingaben die Regel entgegennimmt und was sie zurückgibt.

Eine abstrakte Methode erfüllen

Ein funktionales Interface hat eine zu implementierende abstrakte Methode. Deklarationen, die öffentlichen Instanzmethoden von Object entsprechen, etwa equals(Object), zählen nicht mit. Default-Methoden und statische Methoden fügen keine abstrakten Aufgaben hinzu. Comparator<T> und Runnable sind funktionale Interfaces.

@FunctionalInterface
interface Operation {
    int apply(int a, int b);
}

class Combine {
    static int combine(int a, int b, Operation op) {
        return op.apply(a, b);
    }

    public static void main(String[] args) {
        Operation add = (a, b) -> a + b;
        System.out.println(add.apply(3, 4)); // 7
        System.out.println(combine(3, 4, (x, y) -> x * y)); // 12
    }
}

Das Interface liefert den Methodennamen apply, die beiden Parametertypen int und den Ergebnistyp int. Der Lambda-Ausdruck liefert die Parameternamen und den Rumpf. Er erstellt eine Implementierung, die über Operation verwendet werden kann; apply wird erst aufgerufen, wenn das Programm die Methode aufruft.

combine übergibt seine beiden Zahlen immer an op. Der aufrufende Code ändert das Verhalten, indem er Addition oder Multiplikation vorgibt. Auf diese Weise erhält auch sort eine Ordnungsregel und filter eine Bedingung.

Die Syntax lesen

Ein Lambda-Ausdruck hat Parameter, -> und danach einen Ausdruck oder einen Block. Bei einem einzelnen Parameter mit abgeleitetem Typ können die Klammern entfallen: w -> w.length() > 5. Bei keinem Parameter ist () nötig, und bei zwei oder mehr Parametern sind Klammern nötig, wie in (a, b) -> a * b. Explizite Typen sind erlaubt: (int a, int b) -> a + b.

Ein Ausdrucksrumpf gibt sein Ergebnis automatisch zurück. Ein Block, der einen Wert liefert, muss ihn zurückgeben:

Operation max = (a, b) -> {
    if (a > b) {
        return a;
    }
    return b;
};
System.out.println(max.apply(3, 9)); // 9

Jeder Pfad durch diesen Block gibt einen int zurück. Geschweifte Klammern um a + b ohne return ergeben keinen gültigen Block, der einen Wert zurückgibt.

Der Zieltyp legt die Bedeutung fest

Der Zieltyp ist das funktionale Interface, das bei einer Zuweisung, einem Argument oder einer Rückgabe erwartet wird. Der Text x -> x * 2 kann zu Function<Integer, Integer> oder UnaryOperator<Integer> passen. Seine Parameter- und Ergebnistypen stammen aus diesem Zieltyp. Object o = () -> 1; schlägt fehl, weil Object keine funktionale Methode vorgibt.

@FunctionalInterface veranlasst den Compiler, die Interface-Definition zu prüfen. Das schützt sinnvollerweise davor, dass später jemand eine zweite unterschiedliche abstrakte Methode hinzufügt. Ohne die Annotation kann ein solches Interface weiterhin deklariert werden, aber ein Lambda-Ausdruck kann seine beiden voneinander unabhängigen Anforderungen nicht implementieren.

Ein Lambda-Ausdruck kann auch mit lokalen Namen in Konflikt geraten. Wenn die umgebende Methode bereits int a deklariert, kann sie in diesem Gültigkeitsbereich keinen Lambda-Parameter namens a deklarieren. Wähle einen anderen Parameternamen. Im Vergleich zu einer anonymen Klasse, die Comparator<String> implementiert, erspart ein Lambda-Ausdruck die wiederholte Klassen- und Methodendeklaration; die Berechnung der Ordnung muss weiterhin den Comparator-Vertrag erfüllen.

Java hat bereits Namen für die häufigen Formen von Verhalten. Wähle ein Interface anhand der Anzahl der Eingaben und der Art des Ergebnisses und rufe dann seine funktionale Methode auf, um das Verhalten auszuführen.

Eine Form für Eingabe und Ausgabe wählen

Diese Interfaces stehen in java.util.function. Für Strings passt w -> w.length() > 5 zu einem Predicate, String::length zu einer Function, die Integer zurückgibt, und System.out::println zu einem Consumer. Ein Supplier wie () -> new ArrayList<String>() erzeugt bei jeder Ausführung von get() eine neue Liste. Eine von filter verwendete Bedingung benötigt Predicate<T>, auch wenn eine Function<T, Boolean> in anderem Code ebenfalls einen booleschen Wert berechnen könnte.

UnaryOperator<T> ist eine Funktion von T auf dasselbe T. BinaryOperator<T> verbindet zwei Werte vom Typ T zu einem T. BiFunction<T, U, R>, BiPredicate<T, U> und BiConsumer<T, U> nehmen zwei Eingaben entgegen. Primitive Spezialisierungen vermeiden das Verpacken: IntPredicate.test(int), IntBinaryOperator.applyAsInt(int, int) und ToIntFunction<T>.applyAsInt(T).

Regeln in einer festgelegten Reihenfolge kombinieren

import java.util.function.Function;
import java.util.function.Predicate;

class Rules {
    public static void main(String[] args) {
        Predicate<String> isLong = w -> w.length() > 5;
        Predicate<String> longB = isLong.and(w -> w.startsWith("b"));
        System.out.println(longB.test("banana")); // true
        System.out.println(isLong.negate().test("kiwi")); // true

        Function<Integer, Integer> twice = x -> x * 2;
        Function<Integer, Integer> inc = x -> x + 1;
        System.out.println(twice.andThen(inc).apply(5)); // 11
        System.out.println(twice.compose(inc).apply(5)); // 12
    }
}

and verlangt beide Bedingungen, or mindestens eine und negate kehrt die Antwort um. Predicate.not(p) negiert ebenfalls ein Predicate. andThen führt zuerst den Empfänger aus; compose führt zuerst sein Argument aus. Hier berechnet die erste Verkettung 10 und dann 11, während die zweite 6 und dann 12 berechnet.

Eine Regel an eine Methode übergeben

static <T> List<T> keep(List<T> list, Predicate<T> test) {
    List<T> kept = new ArrayList<>();
    for (T x : list) {
        if (test.test(x)) kept.add(x);
    }
    return kept;
}

keep(List.of(4, 9, 12, 15), n -> n % 3 == 0) ergibt [9, 12, 15]. Dank T lässt sich die Methode für verschiedene Elementtypen wiederverwenden; das Predicate macht das Auswahlverhalten wiederverwendbar.

Für eine modifizierbare Liste [3, 8, 1, 10, 6] lässt removeIf(n -> n < 5) die Liste [8, 10, 6] übrig. replaceAll(n -> n * 2) ergibt danach [16, 20, 12]. Diese Methoden ändern die Liste; forEach akzeptiert einen Consumer für Aktionen wie die Ausgabe. Kopiere ein Ergebnis von List.of(...) in eine ArrayList, bevor du ändernde Operationen verwendest.

Für Maps nimmt forEach((key, value) -> ...) einen BiConsumer entgegen. merge(word, 1, Integer::sum) speichert 1 für ein neues Wort und erhöht eine vorhandene Anzahl. computeIfAbsent(key, k -> new ArrayList<>()) erzeugt einen Wert für einen fehlenden oder auf null abgebildeten Schlüssel und gibt den resultierenden Wert zurück. Diese Methoden halten die Regel für Abfrage und Aktualisierung zusammen.

Ein Lambda-Ausdruck kann Informationen aus seiner umgebenden Methode verwenden. Wenn sein Rumpf nur eine vorhandene Methode aufruft, drückt eine Methodenreferenz dasselbe Verhalten oft direkter aus.

Eine lokale Variable einfangen

int limit = 10;
Predicate<Integer> small = n -> n < limit;
System.out.println(small.test(7)); // true

Der Lambda-Ausdruck verwendet limit durch Einfangen. Eine eingefangene lokale Variable muss final oder effektiv final sein: Ihr wird einmal ein Wert zugewiesen und sie erhält danach keine Neuzuweisung. Fügt man irgendwo nach dieser ersten Zuweisung limit = 20; hinzu, lässt sich das Einfangen nicht mehr kompilieren, selbst wenn die Neuzuweisung vor dem Lambda-Ausdruck steht.

Die Regel gilt für die lokale Variable, nicht für den gesamten Zustand ihres Objekts. Dies lässt sich kompilieren:

StringBuilder log = new StringBuilder();
Runnable action = () -> log.append("ran");
action.run();
System.out.println(log); // ran

log verweist weiterhin auf denselben Builder. Auch das Aktualisieren eines Felds des umgebenden Objekts ist erlaubt, aber versteckte Änderungen können es erschweren, das Verhalten nachzuvollziehen.

Der Versuch, numbers.forEach(n -> total += n) mit einem lokalen int total = 0 zu verwenden, schlägt fehl, weil er die eingefangene Variable ändert. Verwende eine Schleife, wenn die Aufgabe eine Aktualisierung ist, oder berechne ein Ergebnis direkt mit numbers.stream().mapToInt(n -> n).sum().

Die vier Referenzformen lesen

Eine Methodenreferenz verwendet :: ohne Argumentliste. Das funktionale Interface als Zieltyp liefert die Eingaben und das erwartete Ergebnis.

Bei der gebundenen Referenz steht das Empfängerobjekt bereits fest: der PrintStream, auf den System.out verweist. Bei der ungebundenen Referenz wird das erste Argument des funktionalen Interfaces zum Empfängerobjekt. So entspricht String::compareToIgnoreCase dem Ausdruck (a, b) -> a.compareToIgnoreCase(b): Der erste String ist das Empfängerobjekt und der zweite das Methodenargument.

Die Referenz auf einen Zieltyp abstimmen

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;

class References {
    public static void main(String[] args) {
        Function<String, Integer> parse = Integer::parseInt;
        Function<String, Integer> length = String::length;
        Supplier<List<String>> fresh = ArrayList::new;
        System.out.println(parse.apply("42")); // 42
        System.out.println(length.apply("stream")); // 6
        System.out.println(fresh.get()); // []
    }
}

Auch eine Konstruktorreferenz kann Argumente entgegennehmen. Student::new passt zu einer Function<String, Student>, wenn ein passender Konstruktor einen String entgegennimmt. Der Zieltyp bestimmt, welche Konstruktorüberladung ausgewählt wird.

Student::getName verweist auf einen Instanz-Getter für jeden übergebenen Studierenden; ein statischer Getter ist nicht nötig. Schreibe einen Lambda-Ausdruck, wenn zusätzliche Arbeit anfällt, wie in s -> s.getPoints() * 2 oder w -> w.length() > 5. String::length() zu schreiben ist ungültig: Die Referenz benennt Verhalten, ohne es an dieser Stelle aufzurufen.

Die natürliche Ordnung eines Objekts ist nicht immer die Ordnung, die eine Aufgabe benötigt. Mit einem separaten Comparator<T> kannst du dieselben Objekte nach unterschiedlichen Regeln sortieren, ohne ihre Klasse zu ändern.

Das Vorzeichen von compare lesen

compare(a, b) gibt eine negative Zahl zurück, wenn a zuerst kommt, null, wenn beide gleich eingeordnet werden, und eine positive Zahl, wenn a nach b kommt. Nur das Vorzeichen zählt. Ein Comparator gibt keinen booleschen Wert zurück.

Comparable<T> gehört zur Klasse und liefert über compareTo ihre natürliche Ordnung. Ein Comparator ist ein separater Wert, der an eine Sortiermethode übergeben wird. Strings haben eine natürliche Zeichenordnung, aber ein Comparator kann sie stattdessen nach Länge sortieren.

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortWords {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>(List.of("ccc", "a", "bb"));
        Comparator<String> byLength =
            (a, b) -> Integer.compare(a.length(), b.length());
        words.sort(byLength);
        System.out.println(words); // [a, bb, ccc]
    }
}

Der Comparator ermittelt die Längen und vergleicht die Zahlen. words.sort ändert die modifizierbare Liste und gibt void zurück; die Methode gibt keine neue Liste zurück. Das Sortieren eines Ergebnisses von List.of(...) wirft eine UnsupportedOperationException, daher erstellt das Beispiel zunächst eine ArrayList-Kopie.

Zahlen sicher vergleichen

Verwende Integer.compare oder Double.compare. Eine Subtraktion kann das Vorzeichen durch Überlauf umkehren: 2_000_000_000 - (-2_000_000_000) ergibt als int den Wert -294.967.296. Dadurch steht die größere Zahl bei aufsteigender Ordnung fälschlich zuerst. Integer.compare(2_000_000_000, -2_000_000_000) gibt korrekt 1 zurück.

Auch die explizite Umwandlung einer Differenz von Double-Werten in int verliert Informationen. (int) (1.2 - 0.7) ist 0, obwohl der erste Wert größer ist. Double.compare(1.2, 0.7) meldet ein positives Ergebnis.

Die Ordnung konsistent halten

Das Vertauschen der Eingaben muss das Vorzeichen des Vergleichs umkehren. Wenn a vor b und b vor c steht, muss a vor c stehen. Werte, deren Vergleich null ergibt, müssen gegenüber jedem anderen Wert gleich eingeordnet werden. Ein Verstoß gegen diese Regeln kann eine falsche Reihenfolge ergeben oder dazu führen, dass die Sortierung eine IllegalArgumentException mit „Comparison method violates its general contract!“ wirft. Gibt man nur 0 oder 1 zurück, lassen sich nicht beide Richtungen ausdrücken.

Javas Listensortierungen und Comparator-basierte Sortierungen von Objekt-Arrays sind stabil: Bei Gleichständen bleibt die ursprüngliche Reihenfolge erhalten. Für die Studierenden Ada 85, Ben 72, Chen 85, Dara 90 und Eli 64 ergibt das Sortieren nach aufsteigender Punktzahl Eli, Ben, Ada, Chen, Dara. Ada bleibt vor Chen, weil beide gleich viele Punkte haben und Ada zuerst vorkam.

Die Beispiele mit Studierenden verwenden diese Klasse und eine modifizierbare Liste:

class Student {
    private final String name;
    private final String group;
    private final int points;

    Student(String name, String group, int points) {
        this.name = name;
        this.group = group;
        this.points = points;
    }
    String getName() { return name; }
    String getGroup() { return group; }
    int getPoints() { return points; }
}

List<Student> students = new ArrayList<>(List.of(
    new Student("Ada", "A", 85), new Student("Ben", "B", 72),
    new Student("Chen", "A", 85), new Student("Dara", "B", 90),
    new Student("Eli", "A", 64)));
students.sort(Comparator.comparingInt(Student::getPoints));
students.forEach(s -> System.out.println(s.getName()));
// Eli, Ben, Ada, Chen, Dara, each on a separate line

Einen Sortieraufruf wählen

list.sort(cmp) und Collections.sort(list, cmp) ändern eine modifizierbare Liste. list.sort(null) fordert die natürliche Ordnung an. Arrays.sort(array, cmp) akzeptiert ein Objekt-Array wie Integer[]; für ein int[] gibt es keine Überladung mit Comparator.

Die natürliche String-Ordnung vergleicht UTF-16-Codeeinheiten. Die Großbuchstaben A–Z stehen vor den Kleinbuchstaben a–z, sodass aus ["banana", "Cherry", "apple"] die Liste [Cherry, apple, banana] wird. String.CASE_INSENSITIVE_ORDER ergibt für diese Wörter [apple, banana, Cherry]. Wähle die Textregel ausdrücklich, wenn die Groß- und Kleinschreibung die Reihenfolge nicht bestimmen soll.

Eine Ordnung nach mehreren Schlüsseln lässt sich am leichtesten als Folge von Entscheidungen lesen: Vergleiche den Hauptschlüssel und vergleiche einen zweiten Schlüssel nur dann, wenn der erste Vergleich einen Gleichstand ergibt. Comparator-Erzeugermethoden drücken diese Entscheidungen direkt aus.

Einen Schlüssel extrahieren und Gleichstände auflösen

Für einen Student mit getName(), getGroup() und getPoints() ordnet Comparator.comparing(Student::getName) nach Namen. comparingInt(Student::getPoints) extrahiert einen int, ohne ihn zu verpacken.

Comparator<Student> ranking =
    Comparator.comparingInt(Student::getPoints)
        .reversed()
        .thenComparing(Student::getName);

Dies ordnet hohe Punktzahlen zuerst und bei gleichen Punkten die Namen aufsteigend. Für Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64) ergibt sich Dara, Ada, Chen, Ben, Eli. Der Namensvergleich wird nur bei einem Punktegleichstand ausgeführt.

reversed auf der richtigen Ebene platzieren

reversed() kehrt alles zuvor Erstellte um. Würde man die Rangfolge nach thenComparing umkehren, würden auch die Namen innerhalb jedes Punktegleichstands umgekehrt. Um Gruppen aufsteigend und Punkte innerhalb jeder Gruppe absteigend zu ordnen, kehre nur den Punkte-Comparator um:

Comparator<Student> byGroup =
    Comparator.comparing(Student::getGroup)
        .thenComparing(
            Comparator.comparingInt(Student::getPoints).reversed());

Das Ergebnis ist Ada, Chen, Eli, Dara, Ben: Gruppe A steht vor B; innerhalb von A steht 85 vor 64. Würde man stattdessen .reversed() ans Ende setzen, würden gegenüber der vorherigen Verkettung sowohl die Gruppen- als auch die Punktreihenfolge umgekehrt.

Regeln für Text und null wählen

Comparator.naturalOrder() folgt Comparable; reverseOrder() kehrt diese Ordnung um. Gib einen Schlüssel-Comparator an, wenn ein Schlüssel eine besondere Behandlung benötigt, wie in Comparator.comparing(Student::getName, String.CASE_INSENSITIVE_ORDER).

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class SortNullable {
    public static void main(String[] args) {
        List<String> words = new ArrayList<>();
        words.add("b");
        words.add(null);
        words.add("a");
        words.sort(Comparator.nullsFirst(Comparator.naturalOrder()));
        System.out.println(words); // [null, a, b]
    }
}

Umschließe den Vergleich auf der Ebene, auf der null vorkommt. nullsLast um den gesamten Student-Comparator behandelt null-Studentenobjekte. Eine Funktion zum Extrahieren des Namens, die null zurückgibt, benötigt einen Comparator mit Nullbehandlung für den Namensschlüssel selbst. Comparatoren für die natürliche Ordnung und gewöhnliche Schlüssel-Comparatoren behandeln null-Schlüssel nicht automatisch.

Map-Einträge sortieren und Typinferenz lösen

Eine HashMap sichert keine Begegnungsreihenfolge zu. Verarbeite ihre Einträge als Stream und wähle ausdrücklich eine Ordnung:

stock.entrySet().stream()
    .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
    .forEach(System.out::println);

Für rice=12, oats=3 und flour=7 gibt dies rice=12, flour=7, oats=3 in getrennten Zeilen aus. Es ordnet die Einträge im Stream, ohne stock neu zu ordnen. Ergänze thenComparing(Map.Entry.comparingByKey()), wenn Werte mit Gleichstand eine vorhersehbare Schlüsselreihenfolge benötigen.

Das explizite <String, Integer> unterstützt die Typinferenz über den verketteten Aufruf hinweg. Ebenso kann Comparator.comparing(s -> s.getName()).reversed() für s den Typ Object ableiten. Verwende Student::getName oder (Student s) -> s.getName(), um den fehlenden Typ anzugeben. Ein benannter Comparator kann beim Sortieren von Listen, mit den Stream-Operationen sorted, min und max oder mit einer geordneten Map oder Menge wiederverwendet werden.

Ein Stream beschreibt, wie eine Folge von Werten verarbeitet wird. Er liest aus einer Quelle, leitet Elemente durch Zwischenoperationen und endet mit einer Terminaloperation, die ein Ergebnis liefert oder eine Aktion ausführt.

Die drei Teile erkennen

import java.util.List;

class CountPasses {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        long passed = points.stream()
            .filter(p -> p >= 60)
            .count();
        System.out.println(passed); // 3
        System.out.println(points); // [72, 45, 90, 58, 81]
    }
}

points.stream() ist die Quelle. filter ist eine Zwischenoperation: Sie gibt einen weiteren Stream zurück. count ist die Terminaloperation: Sie gibt einen long zurück. Die Werte 72, 90 und 81 bestehen den Filter. Das Lesen über den Stream hat 45 und 58 nicht aus points entfernt.

Eine Quelle wählen

Collections stellen stream() bereit. Eine Map stellt Streams über entrySet(), keySet() oder values() bereit. Arrays.stream(array) verarbeitet Array-Elemente als Stream; ein int[] erzeugt einen IntStream. Stream.of("a", "b", "c") liefert aufgezählte Werte.

IntStream.range(1, 5) enthält 1, 2, 3, 4, wobei das Ende ausgeschlossen ist. rangeClosed(1, 5) schließt 5 ein und ergibt die Summe 15. Stream.iterate(1, n -> n * 2) hat keinen festen Endpunkt; .limit(5).toList() sammelt [1, 2, 4, 8, 16]. Ein begrenztes Ergebnis ist beim Verarbeiten dieser unendlichen Folge unerlässlich.

Die verzögerte Ausführung verfolgen

Zwischenoperationen werden verzögert ausgewertet. Das bloße Schreiben von names.stream().map(String::toUpperCase); führt die Umwandlungen nicht aus. Eine Terminaloperation startet die Verarbeitung, und Elemente werden nur bei Bedarf verarbeitet.

String first = java.util.stream.Stream.of("one", "two", "three", "four")
    .filter(w -> w.length() > 3)
    .map(String::toUpperCase)
    .findFirst()
    .orElse("none");
System.out.println(first); // THREE

Die ersten beiden Wörter bestehen den Filter nicht. "three" besteht ihn, wird zu "THREE" und erfüllt findFirst. Das letzte Wort wird nicht benötigt. Das ist Kurzschlussauswertung: Die Antwort steht fest, bevor die ganze Quelle gelesen wurde.

sorted benötigt die gesamte Eingabe, bevor es den ersten sortierten Wert ausgeben kann. Einige andere zustandsbehaftete Operationen, etwa ein sequenzielles distinct, können Werte ausgeben, sobald Eingaben eintreffen. Die Position einer Operation in der Verkettung beeinflusst, wie viel Arbeit nötig ist.

Für ein weiteres Ergebnis einen neuen Stream erstellen

Nach einer Terminaloperation ist der Stream verbraucht. Die erneute Verwendung dieses Streams wirft häufig eine IllegalStateException mit „stream has already been operated upon or closed“. Rufe für eine weitere Pipeline erneut points.stream() auf. Eine Collection ist wiederverwendbarer Speicher; ein Stream ist ein Verarbeitungspfad.

Das Erstellen eines Streams kopiert seine Elemente nicht. Halte die Quelle während der Verarbeitung unverändert. map erzeugt abgebildete Werte; es schreibt sie nicht in die Liste zurück. Für beabsichtigte Änderungen an einer Liste drücken Methoden wie replaceAll und removeIf diese Aufgabe direkt aus. Verwende eine Operation pro Zeile, damit Verarbeitungsreihenfolge und Ergebnistyp sichtbar bleiben.

Verfolge nach jeder Operation sowohl die Werte als auch ihren Typ: Ein späterer Lambda-Ausdruck erhält das aktuelle Stream-Element, nicht das ursprüngliche Quellobjekt.

Vor dem Umwandeln auswählen

filter behält Elemente, die ein Prädikat erfüllen. map ersetzt jedes Element durch einen berechneten Wert. Bei Studierenden mit Gettern für Namen und Punkte muss die Auswahl nach Punkten vor der Abbildung auf Namen erfolgen:

List<String> names = students.stream()
    .filter(s -> s.getPoints() >= 80)
    .map(Student::getName)
    .sorted()
    .toList();

Für Ada 85, Ben 72, Chen 85, Dara 90 und Eli 64 ergibt dies [Ada, Chen, Dara]. Vor map ist der Elementtyp Student. Danach ist der Typ String, sodass kein Punkte-Getter mehr verfügbar ist.

Zu einem Stream primitiver Werte wechseln

Stream<Integer> enthält Referenzen auf Wrapperobjekte und hat keine Methode sum(). mapToInt(Integer::intValue) erzeugt einen IntStream, der numerische Operationen bereitstellt. mapToInt(String::length) misst entsprechend Strings und liefert ihre Längen als primitive Werte.

import java.util.List;
import java.util.stream.IntStream;

class Windows {
    public static void main(String[] args) {
        List<Integer> window = IntStream.rangeClosed(1, 10)
            .skip(2)
            .limit(3)
            .boxed()
            .toList();
        System.out.println(window); // [3, 4, 5]
    }
}

skip(2) entfernt 1 und 2 aus dem Stream. limit(3) behält die nächsten drei Werte. Kehrt man diese Aufrufe um, bleibt nur 3 übrig. boxed() führt zurück zu Stream<Integer>, sodass die Elemente als Objekte gesammelt werden können. mapToObj erzeugt andere Objekte aus primitiven Werten; Streams von long- und double-Werten haben entsprechende Umwandlungsoperationen.

Duplikate entfernen und eine Ordnung wählen

distinct verwendet die Gleichheit von Objekten. Aus ["map", "filter", "map", "sorted", "filter"] wird [map, filter, sorted], und sorted() ergibt danach [filter, map, sorted]. Implementiere für eigene Klassen konsistente Methoden equals und hashCode, wenn übereinstimmende Feldwerte als Duplikate gelten sollen.

sorted() verwendet die natürliche Ordnung. Gib für eine andere Ordnung oder für Objekte ohne natürliche Ordnung einen Comparator an. Das Sortieren eines geordneten Streams ist stabil. Sortiert man die fünf Studierenden nach absteigender Punktzahl und nimmt dann zwei, werden Dara und Ada ausgewählt: Ada steht bei ihrer gleichen Punktzahl in der ursprünglichen Liste vor Chen. Ein Aufruf von limit(2) vor dem Sortieren würde nur die ursprünglichen ersten beiden Studierenden betrachten.

Verschachtelte Folgen abflachen

List<Integer> all = List.of(
        List.of(1, 2), List.of(3), List.of(4, 5, 6))
    .stream()
    .flatMap(List::stream)
    .toList();
System.out.println(all); // [1, 2, 3, 4, 5, 6]

Jede innere Liste wird zu einem Stream, und flatMap fügt ihre Elemente zu einem Stream zusammen. Ersetzt man hier flatMap durch map, ergibt sich ein Stream<Stream<Integer>>: ein Stream-Objekt pro innerer Liste, ohne Abflachung.

peek gibt einen Wert unverändert weiter und kann ihn zur Fehlersuche ausgeben. Seine Aktion wird nur für tatsächlich durchlaufene Elemente ausgeführt, und eine Implementierung kann eine nicht benötigte Stufe überspringen, zum Beispiel bei der Optimierung von count. Verwende es nicht, um notwendige Arbeit auszuführen. Verwende für einen einzelnen größten Wert max(comparator), statt jedes Element zu sortieren und eines zu entnehmen.

Wähle die Terminaloperation anhand des benötigten Ergebnisses: eine Anzahl, eine Zahl, ein Wahrheitswert, ein Element oder eine allgemeine Verknüpfung. Eine leere Eingabe ist immer dann relevant, wenn kein Ergebniswert ausgewählt werden kann.

Eine Zahl berechnen

count() gibt einen long zurück. sum() auf einem Stream primitiver Werte gibt eine Zahl des primitiven Typs des Streams zurück. Für die Punkte [72, 45, 90, 58, 81] ergibt das Filtern nach mindestens 60 und anschließende Summieren 243. Der Mittelwert dieser drei Werte ist 81,0.

import java.util.List;

class PointResults {
    public static void main(String[] args) {
        List<Integer> points = List.of(72, 45, 90, 58, 81);
        int sum = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).sum();
        double average = points.stream().filter(p -> p >= 60)
            .mapToInt(Integer::intValue).average().orElse(0.0);
        System.out.println(sum);     // 243
        System.out.println(average); // 81.0
    }
}

Die zweite Pipeline verwendet einen neuen Stream. Eine leere Summe ist 0, aber ein Mittelwert einer leeren Eingabe hat keinen Wert. average() gibt OptionalDouble zurück, und orElse(0.0) liefert einen gewählten Ersatzwert. Dieser Standardwert ist eine Entscheidung im Programm, nicht der mathematische Mittelwert einer leeren Menge.

Eine int-Summe kann überlaufen. Das Summieren zweier Werte von 2.000.000.000 ergibt als int den Wert -294.967.296. Wandle vor dem Addieren um: mapToInt(...).asLongStream().sum() ergibt 4.000.000.000 als long.

Einen Wert oder keinen behandeln

Ein Optional<T> enthält einen Wert oder keinen Wert. min, max, findFirst, findAny und eine Reduktion ohne neutrales Element geben bei Objekt-Streams optionale Werte zurück. points.stream().max(Integer::compare) ergibt Optional[90]; bei der Ausgabe des Containers erscheint auch der umgebende Text.

Verwende orElse für einen Ersatzwert, orElseGet für einen Ersatz-Supplier, ifPresent für eine Aktion oder map, um einen vorhandenen Wert umzuwandeln. Filtert man nach einem Studierenden mit mehr als 95 Punkten, bildet den ersten Treffer auf einen Namen ab und wendet orElse("nobody") an, ergibt sich für die Daten der fünf Studierenden "nobody". Der Aufruf von get() oder orElseThrow() auf einem leeren optionalen Wert wirft eine NoSuchElementException.

Eine Ja-oder-Nein-Frage stellen

anyMatch fragt, ob mindestens ein Wert die Bedingung erfüllt, allMatch, ob jeder Wert sie erfüllt, und noneMatch, ob keiner sie erfüllt. Sie können enden, sobald die Antwort feststeht. Bei leerer Eingabe ist anyMatch falsch, während allMatch und noneMatch wahr sind: Es gibt keinen Wert, der eine der beiden allgemeinen Aussagen verletzt.

Mit einem neutralen Element verknüpfen

Stream.of(3, 5, 7).reduce(0, Integer::sum) akkumuliert 0, 3, 8, 15. Für die Multiplikation beginne mit 1 und verwende (a, b) -> a * b, um 105 zu erhalten. Ein neutrales Element lässt einen Wert bei der Operation unverändert; 10 ist kein neutrales Element der Addition und würde die Summe fälschlich auf 25 verschieben. Der Akkumulator muss assoziativ sein, damit die Gruppierung das Ergebnis nicht ändert.

Ohne neutrales Element ergibt reduce(Integer::max) den Wert Optional[7] und bei leerer Eingabe einen leeren optionalen Wert. forEach führt hingegen eine Aktion aus und gibt void zurück; es eignet sich zur Ausgabe. Verwende eine Reduktion oder einen Collector, wenn die Aufgabe darin besteht, einen Ergebniswert zu erzeugen.

Ein Collector wandelt einen Stream in eine nützliche Ergebnisstruktur um. Entscheide, was das Ergebnis unterstützen muss: Duplikate, eine Ordnung, spätere Änderungen oder doppelte Map-Schlüssel. Verschiedene Collectoren geben unterschiedliche Zusicherungen.

Eine Liste oder Menge wählen

stream.toList() gibt eine nicht modifizierbare Liste in Begegnungsreihenfolge zurück. Das Hinzufügen oder Entfernen von Elementen wirft eine UnsupportedOperationException. collect(Collectors.toList()) sammelt ebenfalls in einer Liste, garantiert aber keine bestimmte Implementierung oder Modifizierbarkeit. Fordere eine Liste, die du ändern willst, ausdrücklich an:

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

class Gather {
    public static void main(String[] args) {
        List<String> words = Stream.of("a", "b", "a")
            .collect(Collectors.toCollection(ArrayList::new));
        words.add("c");
        System.out.println(words); // [a, b, a, c]
        System.out.println(Stream.of("a", "b", "a")
            .collect(Collectors.toSet()).size()); // 2
    }
}

toSet entfernt Duplikate und sichert keine Reihenfolge zu. toCollection(TreeSet::new) fordert eine sortierte Menge an. Eine Liste behält doppelte Elemente; wähle eine Menge, wenn das Ergebnis eindeutige Werte darstellt.

Text zusammenfügen

Collectors.joining(", ") fügt Strings mit einem Trennzeichen zusammen, ohne ein abschließendes Trennzeichen. Die Form mit drei Argumenten ergänzt außerdem ein Präfix und ein Suffix:

String names = Stream.of("Ada", "Chen", "Dara")
    .collect(Collectors.joining(", ", "[", "]"));
System.out.println(names); // [Ada, Chen, Dara]

Die Elemente müssen Werte vom Typ CharSequence sein, normalerweise Strings. Bilde Studierende mit Student::getName oder Zahlen mit String::valueOf ab, bevor du sie zusammenfügst. Das Zusammenfügen gibt einen String zurück, keine Liste, die nur ähnlich ausgegeben wird.

Map-Schlüssel und Werte wählen

Collectors.toMap(keyFunction, valueFunction) berechnet aus jedem Element einen Eintrag. Bei den fünf Studierenden Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64) ergeben sich beim Zuordnen der Namen zu Punkten fünf Einträge wie Ada=85 und Eli=64.

Bei Gruppenschlüsseln ist es anders: Mehrere Studierende haben dieselbe Gruppe. Ein toMap(Student::getGroup, Student::getPoints) mit zwei Argumenten wirft eine IllegalStateException, wenn ein Schlüssel erneut auftritt, selbst wenn beide Werte 85 sind. Eine Map benötigt einen Ergebniswert pro Schlüssel, und diese Form gibt keine Regel vor, um ihn auszuwählen.

Gib ein drittes Argument an, um doppelte Schlüssel zusammenzuführen:

Map<String, Integer> totals = students.stream()
    .collect(Collectors.toMap(
        Student::getGroup, Student::getPoints, Integer::sum));

Gruppe A erhält 85 + 85 + 64 = 234; Gruppe B erhält 72 + 90 = 162. Ersetzt du Integer::sum durch Math::max, bleiben die höchsten Punktzahlen pro Gruppe erhalten, A=85 und B=90. Verwende die Regel, die zur Aufgabe passt, und keinen beliebigen ersten Wert.

toMap sichert keine bestimmte Map-Reihenfolge zu. Ein viertes Argument kann eine solche anfordern, zum Beispiel TreeMap::new für sortierte Schlüssel. toMap(Student::getName, Student::getPoints, (a, b) -> a, TreeMap::new) behält bei doppelten Namen den ersten Wert und sortiert nach Namen. Ein Collector erspart auch das Erstellen einer externen Liste und deren Änderung in forEach; das Ergebnis wird von der Operation aufgebaut, die zum Sammeln vorgesehen ist.

Ein gruppiertes Ergebnis beantwortet für jeden Schlüssel eine Frage. Eine Partition beantwortet eine Ja-oder-Nein-Frage mit zwei Gruppen. Ein nachgeschalteter Collector bestimmt, was jede Gruppe speichert.

Nach einem berechneten Schlüssel gruppieren

groupingBy(classifier) erzeugt eine Map, die jedem vorkommenden Schlüssel eine Liste seiner Elemente zuordnet. Gruppiert man ["fig", "kiwi", "pear", "plum", "apple", "mango", "banana"] nach Wortlänge, erhält die Länge 4 die Liste [kiwi, pear, plum]. Für fehlende Längen gibt es keinen Eintrag; eine Abfrage gibt null zurück. Verwende daher getOrDefault(key, List.of()), wenn eine leere Liste nützlich ist.

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

class WordGroups {
    public static void main(String[] args) {
        List<String> words = List.of(
            "fig", "kiwi", "pear", "plum", "apple", "mango", "banana");
        Map<Integer, Long> counts = words.stream()
            .collect(Collectors.groupingBy(
                String::length, TreeMap::new, Collectors.counting()));
        System.out.println(counts); // {3=1, 4=3, 5=2, 6=1}
    }
}

Die Klassifikationsfunktion wählt ganzzahlige Schlüssel. TreeMap::new ordnet diese Schlüssel. counting() ersetzt die Liste jeder Gruppe durch ihre Größe als Long. Der Ergebnistyp ist daher Map<Integer, Long>, keine Map von Ganzzahlen auf Ganzzahlen.

Ändern, was eine Gruppe speichert

Für die Studierenden Ada (A, 85), Ben (B, 72), Chen (A, 85), Dara (B, 90), Eli (A, 64) bietet das Gruppieren nach Student::getGroup diese Möglichkeiten:

Ein nachgeschalteter Collector arbeitet innerhalb jeder Gruppe. Für A ist der Mittelwert 234 dividiert durch 3, also 78,0; der Mittelwert von B ist 81,0. maxBy und minBy speichern ein Optional, das den Extremwert der jeweiligen Gruppe enthält. Einfaches groupingBy sichert keinen bestimmten Map-Typ und keine Schlüsselreihenfolge zu; die Form mit Map-Fabrik ermöglicht eine ausdrückliche Wahl.

In zwei Antworten aufteilen

Map<Boolean, List<String>> partition = students.stream()
    .collect(Collectors.partitioningBy(
        s -> s.getPoints() >= 80,
        Collectors.mapping(Student::getName, Collectors.toList())));

Die Liste für true ist [Ada, Chen, Dara], die Liste für false ist [Ben, Eli]. Beide booleschen Schlüssel sind vorhanden, auch wenn eine Seite keine Studierenden enthält. Mit nachgeschaltetem counting() enthalten leere Seiten 0 als Long. groupingBy mit einer booleschen Klassifikationsfunktion erstellt dagegen nur Schlüssel, die vorkommen.

Die erstellte Map verarbeiten

Ein gruppiertes Ergebnis ist eine gewöhnliche Map. Durchlaufe sie mit forEach((group, value) -> ...) oder verarbeite ihre Einträge als Stream. Für die Mittelwerte A=78,0 und B=81,0 gibt averages.entrySet().stream().max(Map.Entry.comparingByValue()) ein Optional<Map.Entry<String, Double>> mit B=81.0 zurück. Der optionale Wert umschließt den Eintrag mit dem höchsten Wert; er ist nicht der einfache Wert 81,0. In einem separaten Schritt kann dieser Eintrag auf seinen Schlüssel oder Wert abgebildet und eine leere Map behandelt werden.

Eine vollständige Datenaufgabe hat oft zwei Stufen: zuerst die Eingabe zusammenfassen, dann die Zusammenfassung abfragen. Wähle Streams, wenn sich diese Stufen natürlich als Standardoperationen lesen lassen, und Schleifen, wenn eine explizite Steuerung die Arbeit klarer macht.

Messwerte mitteln und dann Städte auswählen

Angenommen, ein Reading hat getCity() und getCelsius(). Die Messwerte in Grad Celsius sind Oslo 4,5, Lima 19,0, Oslo 6,0, Cairo 27,5 und Lima 21,0.

class Reading {
    private final String city;
    private final double celsius;
    Reading(String city, double celsius) {
        this.city = city;
        this.celsius = celsius;
    }
    String getCity() { return city; }
    double getCelsius() { return celsius; }
}

Erstelle die Eingabeliste vor jeder der beiden Implementierungen:

List<Reading> readings = List.of(
    new Reading("Oslo", 4.5), new Reading("Lima", 19.0),
    new Reading("Oslo", 6.0), new Reading("Cairo", 27.5),
    new Reading("Lima", 21.0));

Map<String, Double> averages = readings.stream()
    .collect(Collectors.groupingBy(
        Reading::getCity,
        TreeMap::new,
        Collectors.averagingDouble(Reading::getCelsius)));

List<String> warmCities = averages.entrySet().stream()
    .filter(e -> e.getValue() > 15)
    .map(Map.Entry::getKey)
    .toList();

Das erste Ergebnis ist {Cairo=27.5, Lima=20.0, Oslo=5.25}. Der Mittelwert von Oslo ist (4.5 + 6.0) / 2, also 5,25. Der von Lima ist 20,0. Das zweite Ergebnis ist [Cairo, Lima]; die TreeMap sorgt für eine aufsteigende Reihenfolge der Städte. Filtere die Mittelwerte nach dem Gruppieren: Filterst du zuerst einzelne Messwerte, beantwortest du eine andere Frage.

Für den höchsten einzelnen Messwert verwende readings.stream().max(Comparator.comparingDouble(Reading::getCelsius)). Das Ergebnis ist ein optionaler Wert mit dem Messwert aus Cairo, nicht definitionsgemäß die Stadt mit dem höchsten Mittelwert. Bei anderen Daten können diese Aufgaben unterschiedliche Antworten haben.

Dieselbe Berechnung mit Schleifen ausdrücken

Map<String, List<Double>> byCity = new TreeMap<>();
for (Reading r : readings) {
    byCity.computeIfAbsent(r.getCity(), k -> new ArrayList<>())
        .add(r.getCelsius());
}
Map<String, Double> averages = new TreeMap<>();
for (Map.Entry<String, List<Double>> e : byCity.entrySet()) {
    double sum = 0;
    for (double value : e.getValue()) sum += value;
    averages.put(e.getKey(), sum / e.getValue().size());
}
System.out.println(averages);
// {Cairo=27.5, Lima=20.0, Oslo=5.25}

Dies sind alternative Implementierungen desselben Ergebnisses; jede Gruppe ist nicht leer, weil sie durch einen Messwert erzeugt wurde. Der Stream macht das Gruppieren und Mitteln in einem Collector deutlich. Die Schleifen zeigen die Zwischenlisten und die Summe.

Das Verarbeitungsverhalten vorhersehbar halten

Ein Lambda-Ausdruck in einer Pipeline sollte aus seiner Eingabe rechnen, ohne externen Zustand zu ändern. Für die Punkte [72, 45, 90, 58, 81] erzeugt filter(p -> p >= 60).toList() direkt [72, 90, 81]. Fügt man innerhalb von forEach Werte zu einer externen Liste hinzu, verbirgt sich diese Aufgabe des Ergebnisaufbaus in einer Aktion.

Ändere eine ArrayList als Quelle nicht innerhalb ihrer Pipeline: Das Hinzufügen von Elementen aus einem forEach heraus kann eine ConcurrentModificationException werfen. Sammle neue Elemente zuerst separat und füge sie nach Abschluss der Verarbeitung hinzu. Eine eingefangene finale Referenz kann nach Javas Typregeln eine Zustandsänderung erlauben; das macht eine solche Änderung innerhalb eines Streams nicht geeignet.

Den klareren Kontrollfluss wählen

Verwende eine Schleife, wenn du benachbarte Indizes, eine komplizierte Abbruchbedingung oder mehrere aufeinander abgestimmte Aktualisierungen benötigst. Verwende Streams für eine gut lesbare Auswahl, Umwandlung und Sammlung. Die Stream-Syntax allein garantiert keine Geschwindigkeit. Benenne ein langes Prädikat oder einen langen Comparator und teile eine lange Verkettung an einem aussagekräftigen Zwischenergebnis auf. Untersuche zur Fehlersuche mit peek eine Stufe oder sammle sie in einer Liste und gib diese aus; fahre mit einem neuen Stream dieser Liste fort, statt eine verbrauchte Pipeline wiederzuverwenden.