CodeGym /Kurse /JAVA 25 SELF /Fortgeschrittene Kollektoren

Fortgeschrittene Kollektoren

JAVA 25 SELF
Level 31, Lektion 4
Verfügbar

1. Einführung

Wenn Sie mit Collections über das Stream API arbeiten, müssen Sie oft nicht nur Elemente gruppieren, sondern auch sofort etwas damit tun: transformieren, filtern, in einen anderen Collection-Typ sammeln. Dafür gibt es in Java Downstream-Kollektoren – verschachtelte Kollektoren, die auf jede Gruppe oder jeden Teil der Daten angewendet werden.

Was ist ein Downstream-Collector?

Das ist ein Collector, der auf das Ergebnis einer Gruppierung oder Aufteilung angewendet wird. Zum Beispiel können Sie Studierende mit groupingBy nach Kurs gruppieren und innerhalb jeder Gruppe nur die Namen oder nur die Bestplatzierten sammeln (etwa mit einem Schwellenwert 4.5 beim GPA).

Beispiele

mapping

Ermöglicht, die Elemente einer Gruppe vor dem Sammeln zu transformieren.

Map<Integer, List<String>> namesByCourse = students.stream()
    .collect(Collectors.groupingBy(
        Student::getCourse,
        Collectors.mapping(Student::getName, Collectors.toList())
    ));
  • Wir gruppieren die Studierenden nach Kurs.
  • Für jede Gruppe sammeln wir nur die Namen (nicht die ganzen Objekte).

filtering

Ermöglicht das Filtern von Elementen innerhalb der Gruppe (z. B. nur GPA >= 4.5 behalten).

Map<Integer, List<Student>> honorsByCourse = students.stream()
    .collect(Collectors.groupingBy(
        Student::getCourse,
        Collectors.filtering(s -> s.getGpa() >= 4.5, Collectors.toList())
    ));

In jeder Gruppe behalten wir nur die Studierenden mit hohem GPA.

flatMapping

Ermöglicht das „Entfalten“ verschachtelter Collections innerhalb der Gruppen.

Map<String, Set<String>> tagsByAuthor = books.stream()
    .collect(Collectors.groupingBy(
        Book::getAuthor,
        Collectors.flatMapping(
            book -> book.getTags().stream(),
            Collectors.toSet()
        )
    ));

Für jede Autorin/jeden Autor sammeln wir die eindeutigen Tags aller Bücher.

partitioningBy mit Downstream

Funktioniert ähnlich wie groupingBy, teilt aber anhand einer booleschen Bedingung in zwei Gruppen.

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

Wir teilen die Studierenden in Bestanden/Nicht bestanden; innerhalb jeder Gruppe – nur die Namen.

2. teeing: gleichzeitige Aggregation mit zwei Kollektoren

Manchmal müssen mehrere Aggregate über einen Stream gleichzeitig berechnet werden: zum Beispiel Summe und Durchschnitt oder Minimum und Maximum. Dafür gibt es seit Java 12+ den Collector teeing.

Wie funktioniert teeing?

Sie übergeben zwei Kollektoren und eine Funktion, die deren Ergebnisse zusammenführt.

Syntax:

Collectors.teeing(collector1, collector2, (result1, result2) -> ...)

Beispiele

Minimum + Maximum

Optional<MinMax> minMax = numbers.stream()
    .collect(Collectors.teeing(
        Collectors.minBy(Integer::compareTo),
        Collectors.maxBy(Integer::compareTo),
        (min, max) -> min.isPresent() && max.isPresent() ? new MinMax(min.get(), max.get()) : null
    ));

Wir ermitteln Minimum und Maximum in einem Schritt.

Summe + Durchschnitt

Result result = numbers.stream()
    .collect(Collectors.teeing(
        Collectors.summingInt(Integer::intValue),
        Collectors.averagingInt(Integer::intValue),
        (sum, avg) -> new Result(sum, avg)
    ));

Wir erhalten ein Objekt mit Summe und Durchschnittswert.

Beispiel: Gehaltsbericht

SalaryStats stats = employees.stream()
    .collect(Collectors.teeing(
        Collectors.summingInt(Employee::getSalary),
        Collectors.averagingInt(Employee::getSalary),
        SalaryStats::new
    ));

In SalaryStats speichern wir sowohl Summe als auch Durchschnitt.

3. toUnmodifiableList/Set/Map und collectingAndThen zum „Einfrieren“

In modernen Java-Versionen gibt es Collections, die nach ihrer Erstellung nicht mehr verändert werden können – unveränderliche (unmodifiable). Das ist praktisch für APIs, bei denen es wichtig ist, dass das Ergebnis nicht versehentlich geändert werden kann.

toUnmodifiableList/Set/Map

  • Geben eine unveränderliche Collection zurück.
  • Jeder Versuch, ein Element hinzuzufügen oder zu entfernen, führt zu UnsupportedOperationException.

Beispiele:

List<String> names = students.stream()
    .map(Student::getName)
    .collect(Collectors.toUnmodifiableList());
Map<Integer, Student> byId = students.stream()
    .collect(Collectors.toUnmodifiableMap(Student::getId, Function.identity()));

collectingAndThen

Ermöglicht, eine Funktion auf das Ergebnis des Collectors anzuwenden – zum Beispiel die Collection „einzufrieren“.

List<String> names = students.stream()
    .map(Student::getName)
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        Collections::unmodifiableList
    ));

Zuerst sammeln wir in eine normale Liste, dann machen wir sie unveränderlich.

Beispiel mit Set:

Set<String> tags = books.stream()
    .flatMap(book -> book.getTags().stream())
    .collect(Collectors.collectingAndThen(
        Collectors.toSet(),
        Set::copyOf // Java 10+
    ));

4. Pipeline-Anwendungsfälle

Berichte und Statistiken nach Segmenten

Mit fortgeschrittenen Kollektoren lassen sich komplexe Berichte und Statistiken „in einer Zeile“ erstellen.

Beispiel: Durchschnittsgehalt nach Abteilungen

Map<String, Double> avgSalaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.averagingInt(Employee::getSalary)
    ));

Beispiel: Top 3 der teuersten Produkte pro Kategorie

Map<String, List<Product>> top3ByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.collectingAndThen(
            Collectors.toList(),
            list -> list.stream()
                        .sorted(Comparator.comparing(Product::getPrice).reversed())
                        .limit(3)
                        .toList()
        )
    ));

Unveränderliches Ergebnis als API-Vertrag

Wenn Ihre Methode eine Collection zurückgibt, die nicht verändert werden kann, schützt das vor versehentlichen Fehlern und macht das API robuster.

public List<String> getTags() {
    return tags.stream()
        .collect(Collectors.toUnmodifiableList());
}

Der Benutzer kann getTags().add("neuer Tag") nicht ausführen – es wird eine Exception geworfen.

Beispiel: Bericht mit mehreren Aggregaten (teeing)

public SalaryReport getSalaryReport(List<Employee> employees) {
    return employees.stream()
        .collect(Collectors.teeing(
            Collectors.averagingInt(Employee::getSalary),
            Collectors.summingInt(Employee::getSalary),
            SalaryReport::new
        ));
}

In SalaryReport speichern wir sowohl das Durchschnitts- als auch das Gesamtgehalt.

5. Typische Fehler und Besonderheiten

Fehler Nr. 1: Unveränderlichkeit vergessen. Wenn Sie eine normale Liste zurückgeben, kann sie verändert werden. Verwenden Sie toUnmodifiableList/Set/Map oder collectingAndThen, um das Ergebnis zu „einfrieren“.

Fehler Nr. 2: Falscher Downstream-Kollektor. Wenn Sie Elemente innerhalb der Gruppe transformieren müssen – verwenden Sie mapping; wenn Sie filtern müssen – filtering; wenn Sie verschachtelte Collections „entfalten“ müssen – flatMapping.

Fehler Nr. 3: UnsupportedOperationException. Tritt auf, wenn versucht wird, eine Collection zu verändern, die über toUnmodifiableList/Set/Map gesammelt oder mit collectingAndThen „eingefroren“ wurde.

Fehler Nr. 4: Verlust der Eindeutigkeit/Kollisionen bei Schlüsseln. toUnmodifiableSet erfordert eindeutige Elemente, und toUnmodifiableMap – eindeutige Schlüssel; andernfalls erhalten Sie während des Sammelns eine Exception.

1
Aufgabe
JAVA 25 SELF, Level 31, Lektion 4
Gesperrt
Sortierung der Bewerber an der Akademie für Große Leistungen 📜
Sortierung der Bewerber an der Akademie für Große Leistungen 📜
1
Aufgabe
JAVA 25 SELF, Level 31, Lektion 4
Gesperrt
Schnellanalyse des Finanzportfolios 💰
Schnellanalyse des Finanzportfolios 💰
1
Umfrage/Quiz
Gruppierung und Aggregation, Level 31, Lektion 4
Nicht verfügbar
Gruppierung und Aggregation
Stream API: Gruppierung und Aggregation
Kommentare
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION