Detaillierte Erläuterung der Java8 Collectors-Klasse (1)

  CollectorsKlassen sind Hilfsklassen zum Sammeln und Zusammenfassen von Streams. Es bietet viele Methoden zum Gruppieren, Zählen, Konvertieren, Partitionieren, Verbinden, Reduzieren und anderen Vorgängen im Stream, wodurch die Verarbeitung von Erfassungsdaten komfortabler wird.

        Bei Verwendung Collectorsder Klasse können wir verschiedene Verarbeitungsmethoden für den Stream implementieren, indem wir die darin enthaltenen Methoden aufrufen. Um beispielsweise die Elemente im Stream in einer Liste zu sammeln, können Sie toList()die Methode verwenden; um nach bestimmten Bedingungen zu gruppieren, können Sie groupingBy()die Methode verwenden; um die Anzahl der Elemente im Stream zu zählen, können Sie counting()die Methode usw. verwenden An.

        Darüber hinaus unterstützt die Klasse auch benutzerdefinierte Collectors. Das heißt, wir können benutzerdefinierte Collectors schreiben, die Collectorsdie Schnittstelle entsprechend unseren eigenen Anforderungen implementieren , und sie dann direkt im Code verwenden. CollectorDiese Funktion ist in einigen komplexen Anwendungsszenarien sehr nützlich.

Konvertieren

auflisten()

  Collectors.toList()Eine Methode ist eine von einer Klasse in Java bereitgestellte Methode Collectorszum Sammeln von Elementen in einem Stream in einer Sammlung.List

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toList());

Im obigen Beispiel erstellen wir einen ganzzahligen Stream mit 1 bis 5 und verwenden die collectMethode mit der Collectors.toList()Methode, um die Elemente im Stream in einer ListSammlung zu sammeln. Die resultierende listSammlung enthält alle Elemente im Stream, d. h {1, 2, 3, 4, 5}.

Es ist zu beachten, dass Collectors.toList()die Methode eine unveränderliche ListSammlung zurückgibt, sodass sie nicht hinzugefügt oder gelöscht werden kann, die darin enthaltenen Elemente jedoch geändert werden können. Wenn wir eine modifizierbare Sammlung benötigen List, können wir sie wie folgt umwandeln ArrayList:

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(ArrayList::new));

Im obigen Code verwenden wir Collectors.toCollection()die Methode und geben den zu erstellenden Sammlungstyp an ArrayList, damit wir eine veränderbare ListSammlung erhalten können.

Kurz gesagt, Collectors.toList()diese Methode wird in der tatsächlichen Entwicklung sehr häufig verwendet. Sie kann die Elemente im Stream bequem in einer ListSammlung sammeln und unsere Datenverarbeitungsanforderungen weiter erfüllen.

toSet()

Collectors.toSet()Eine Methode ist eine von einer Klasse in Java bereitgestellte Methode Collectorszum Sammeln von Elementen in einem Stream in einer Sammlung.Set

Set<Integer> set = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toSet());

Im obigen Beispiel erstellen wir einen ganzzahligen Stream mit 1 bis 5 und verwenden die collectMethode mit der Collectors.toSet()Methode, um die Elemente im Stream in einer SetSammlung zu sammeln. Die resultierende setSammlung enthält alle Elemente im Stream, d. h {1, 2, 3, 4, 5}.

Es ist zu beachten, dass Collectors.toSet()die Methode eine unveränderliche SetSammlung zurückgibt, sodass sie nicht hinzugefügt oder gelöscht werden kann, die darin enthaltenen Elemente jedoch geändert werden können. Wenn wir eine modifizierbare Sammlung benötigen Set, können wir sie wie folgt umwandeln HashSet:

Set<Integer> set = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(HashSet::new));

Im obigen Code verwenden wir Collectors.toCollection()die Methode und geben den zu erstellenden Sammlungstyp an HashSet, damit wir eine veränderbare SetSammlung erhalten können.

Collectors.toSet()Diese Methode wird in der tatsächlichen Entwicklung sehr häufig verwendet. Sie kann die Elemente im Stream bequem in einer SetSammlung sammeln und unsere Datenverarbeitungsanforderungen weiter erfüllen.

toCollection(Supplier<C>collectionFactory)

Collectors.toCollection(Supplier<C> collectionFactory)Eine Methode ist eine von einer Klasse in Java Collectorsbereitgestellte Methode zum Sammeln von Elementen in einem Stream in einer Sammlung eines bestimmten Typs.

Die Methode benötigt ein Argument, eine Supplier<C>funktionale Schnittstelle vom Typ, wobei Ces sich um den Typ der zu erstellenden Sammlung handelt. Wenn wir beispielsweise eine LinkedListSammlung erstellen möchten, könnten wir diese Methode wie folgt verwenden:

List<Integer> list = Stream.of(1, 2, 3, 4, 5)
    .collect(Collectors.toCollection(LinkedList::new));

 Im obigen Beispiel verwenden wir Collectors.toCollection()die Methode und übergeben eine LinkedList::newFunktion, um eine LinkedListSammlung vom Typ zu erstellen. Die resultierende listSammlung enthält alle Elemente im Stream, d. h {1, 2, 3, 4, 5}.

Es ist zu beachten, dass Collectors.toCollection()die Methode eine veränderbare Sammlung zurückgibt, sodass diese hinzugefügt oder gelöscht werden kann.

Kurz gesagt, Collectors.toCollection()diese Methode wird in der tatsächlichen Entwicklung sehr häufig verwendet. Sie kann die Elemente im Stream bequem in einem bestimmten Sammlungstyp sammeln, um unsere Datenverarbeitungsanforderungen weiter zu erfüllen. Gleichzeitig ist diese Methode sehr flexibel und es können verschiedene Arten von Sammlungsfabriken übergeben werden, um je nach tatsächlichem Bedarf unterschiedliche Arten von Sammlungen zu erstellen.

toConcurrentMap

Collectors.toConcurrentMap()Eine Methode ist eine von einer Klasse in Java bereitgestellte Methode Collectorszum Sammeln der Elemente in einem Stream in einer gleichzeitigen . MapEs verfügt über mehrere Überladungen, von denen die einfachste keinen Mapübergebenen Implementierungstyp erfordert:

ConcurrentMap<Integer, String> concurrentMap = Stream.of("a", "b", "c")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity()
    ));

Im obigen Beispiel haben wir toConcurrentMap()die Methode verwendet, um eine Parallelität Mapmit der Länge der Zeichenfolge als Schlüssel und der Zeichenfolge selbst als Wert zu erstellen. Konkret akzeptiert diese Methode zwei Parameter:

• Eine funktionale Schnittstelle  keyMapper, die ausdrückt, wie Elemente im Stream in Schlüssel umgewandelt werden;
• Eine funktionale Schnittstelle,  valueMapperdie ausdrückt, wie Elemente eines Streams in Werte konvertiert werden.

Für den Stream im obigen Beispiel String::lengthkonvertiert die funktionale Schnittstelle die Zeichenfolge in ihre Länge und Function.identity()die funktionale Schnittstelle ordnet die Zeichenfolge sich selbst zu. Das so erhaltene Ergebnis ist:

{1=a, 2=b, 3=c}

toConcurrentMap()Es ist zu beachten, dass die Methode eine Ausnahme auslöst  , wenn der Stream doppelte Schlüssel enthält IllegalStateException. Über den dritten Parameter können wir angeben, wie das Problem doppelter Schlüssel gelöst werden soll. Wenn wir beispielsweise die Werte, die doppelten Schlüsseln entsprechen, in einer Zeichenfolge kombinieren möchten, können wir diese Methode wie folgt verwenden:

ConcurrentMap<Integer, String> concurrentMap = Stream.of("aa", "bbb", "cc")
    .collect(Collectors.toConcurrentMap(
        String::length,
        Function.identity(),
        (s1, s2) -> s1 + "|" + s2
    ));

 Im obigen Beispiel übergeben wir eine Zusammenführungsfunktion (s1, s2) -> s1 + "|" + s2. Wenn doppelte Schlüssel vorhanden sind, werden die entsprechenden Werte zusammengeführt und |durch getrennt. Das so erhaltene Ergebnis ist:

{2=aa|cc, 3=bbb}

Collectors.toConcurrentMap()Diese Methode wird in der tatsächlichen Entwicklung sehr häufig verwendet. Sie kann die Elemente im Stream bequem in einer Parallelität sammeln Mapund bietet eine umfassende Möglichkeit, Probleme wie doppelte Schlüssel zu lösen.

toMap

Collectors.toMap()MapMethode ist eine Methode , mit der die Elemente des Streams in einer . Es verfügt über mehrere Überladungen, von denen die einfachste keinen Mapübergebenen Implementierungstyp erfordert:

Map<Integer, String> map = Stream.of("a", "b", "c")
    .collect(Collectors.toMap(
        String::length,
        Function.identity()
    ));

Im obigen Beispiel haben wir toMap()eine mit der Methode erstellt Map, die die Länge der Zeichenfolge als Schlüssel und die Zeichenfolge selbst als Wert verwendet. Konkret akzeptiert diese Methode zwei Parameter:

• Eine funktionale Schnittstelle  keyMapper, die ausdrückt, wie Elemente im Stream in Schlüssel umgewandelt werden;
• Eine funktionale Schnittstelle,  valueMapperdie ausdrückt, wie Elemente eines Streams in Werte konvertiert werden.

Für den Stream im obigen Beispiel String::lengthkonvertiert die funktionale Schnittstelle die Zeichenfolge in ihre Länge und Function.identity()die funktionale Schnittstelle ordnet die Zeichenfolge sich selbst zu. Das so erhaltene Ergebnis ist:

{1=a, 2=b, 3=c}

toMap()Es ist zu beachten, dass die Methode eine Ausnahme auslöst  , wenn der Stream doppelte Schlüssel enthält IllegalStateException. Über den dritten Parameter können wir angeben, wie das Problem doppelter Schlüssel gelöst werden soll. Wenn wir beispielsweise die Werte, die doppelten Schlüsseln entsprechen, in einer Zeichenfolge kombinieren möchten, können wir diese Methode wie folgt verwenden:

Map<Integer, String> map = Stream.of("aa", "bbb", "cc")
    .collect(Collectors.toMap(
        String::length,
        Function.identity(),
        (s1, s2) -> s1 + "|" + s2
    ));

Im obigen Beispiel übergeben wir eine Zusammenführungsfunktion (s1, s2) -> s1 + "|" + s2. Wenn doppelte Schlüssel vorhanden sind, werden die entsprechenden Werte zusammengeführt und |durch getrennt. Das so erhaltene Ergebnis ist:

{2=aa|cc, 3=bbb}

Collectors.toMap()Diese Methode wird in der tatsächlichen Entwicklung sehr häufig verwendet. Sie kann die Elemente im Stream bequem in einem zusammenfassen Mapund bietet umfassende Möglichkeiten zur Behebung von Problemen wie doppelten Schlüsseln.

Gruppe

groupingBy(Funktion<? super T, ? erweitert K> Klassifikator)

Collectors.groupingBy()Die Methode ist eine von der Klasse in Java Collectorsbereitgestellte Methode , um die Elemente im Stream gemäß dem angegebenen Klassifizierer zu gruppieren. Konkret akzeptiert die Methode einen Parameter:

• Eine funktionale Schnittstelle,  classifierdie darstellt, wie Elemente in einem Stream klassifiziert werden.

Diese Methode hat zwei überladene Formen, von denen die einfachste nur eine Klassifikatorfunktion übergeben muss:

Map<K, List<T>> map = stream.collect(Collectors.groupingBy(classifier));

In,

• stream ist der zu verarbeitende Stream;
• classifier ist eine funktionale Schnittstelle zum Zuordnen jedes Elements im Stream zu einem Sortierschlüssel  K.

Wir haben beispielsweise eine Liste mit Zeichenfolgen und möchten diese nach Zeichenfolgenlänge gruppieren:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
Map<Integer, List<String>> map = list.stream().collect(Collectors.groupingBy(String::length));

 Im obigen Code verwenden wir String::lengthdie funktionale Schnittstelle, um einen String in seine Länge umzuwandeln und ihn als Sortierschlüssel zu verwenden. Das Ergebnis der Operation ist wie folgt:

{3=[date], 5=[apple, cherry], 6=[banana], 10=[elderberry]}

Es ist zu beachten, dass groupingBy()die Methode ein MapObjekt zurückgibt, wobei der Schlüssel der Kategorieschlüssel und der Wert eine Liste von Elementen ist, die dem Kategorieschlüssel entsprechen. Im obigen Beispiel gibt es zwei Zeichenfolgen mit der Länge 5, daher werden beide derselben Liste hinzugefügt.

Zusätzlich zu den oben genannten Methoden Collectors.groupingBy()stellt die Methode auch einen zweiten Parameter bereit downstream, der zur weiteren Verarbeitung der gruppierten Ergebnisse verwendet wird. Beispielsweise können wir Collectors.counting()die Methode verwenden, um die Anzahl der Elemente in jeder Gruppe zu zählen:

Map<Integer, Long> map = list.stream()
    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

Im obigen Code verwenden wir Collectors.counting()die Methode als Downstream-Parameter, zählen die Anzahl der Elemente in jeder Gruppe und kapseln das Ergebnis als Long-Typ. Das Ergebnis der Operation ist wie folgt:

{3=1, 5=2, 6=1, 10=1}

Collectors.groupingBy()Methode ist eine sehr leistungsfähige Gruppierungsoperation in Java, die die Elemente im Stream gemäß dem angegebenen Klassifikator gruppieren kann und verschiedene weitere Verarbeitungsmethoden wie Statistiken, Aggregation, Sortierung usw. unterstützt.

groupingByConcurrent(Function<? super T, ? erweitert K> Klassifikator)

  Collectors.groupingByConcurrent()Die Methode Collectors.groupingBy()ist der Methode sehr ähnlich. Beide werden verwendet, um die Elemente im Stream gemäß dem angegebenen Klassifikator zu gruppieren. Der Unterschied Collectors.groupingBy()besteht darin, dass Collectors.groupingByConcurrent()die Methode ein threadsicheres (gleichzeitiges) ConcurrentMapObjekt zurückgibt.

groupingByConcurrent()Die Verwendung der Methode groupingBy()ähnelt der von , außerdem gibt es zwei überladene Formen. Die einfachste Form ist wie folgt:

ConcurrentMap<K, List<T>> map = stream.collect(Collectors.groupingByConcurrent(classifier));

In,

• stream ist der zu verarbeitende Stream;
• classifier ist eine funktionale Schnittstelle zum Zuordnen jedes Elements im Stream zu einem Sortierschlüssel  K.

Wir haben beispielsweise eine Liste mit Zeichenfolgen und möchten diese nach Zeichenfolgenlänge gruppieren:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");
ConcurrentMap<Integer, List<String>> map = list.parallelStream()
    .collect(Collectors.groupingByConcurrent(String::length));

Im obigen Code verwenden wir parallelStream()die Methode, um die Liste in einen parallelen Stream umzuwandeln, um Vorgänge in einer Multithread-Umgebung zu gruppieren. Das Ergebnis der Operation ist wie folgt:

{3=[date], 5=[apple, cherry], 6=[banana], 10=[elderberry]}

        Es ist zu beachten, dass groupingByConcurrent()die Methode groupingBy()wie die Methode ein MapObjekt zurückgibt, wobei der Schlüssel der Kategorieschlüssel und der Wert eine Liste von Elementen ist, die dem Kategorieschlüssel entsprechen. Im obigen Beispiel gibt es zwei Zeichenfolgen mit der Länge 5, daher werden beide derselben Liste hinzugefügt.

  Collectors.groupingByConcurrent()Die Methode Collectors.groupingBy()ist der Methode sehr ähnlich und kann als Thread-sichere und nicht-Thread-sichere Version der Gruppierungsoperation betrachtet werden. In einer Multithread-Umgebung groupingByConcurrent()weist die Methode eine bessere Leistung und Parallelität auf und eignet sich für die Verarbeitung großer Datenmengen und Szenarien mit hoher Parallelität, beansprucht jedoch entsprechend mehr Systemressourcen.

Kartierung()

   Collectors.mapping()Die Methode ist ein neuer Collector (Collector) in Java 8. Es kann verwendet werden, um Elemente in einem Stream abzubilden, bevor sie mit anderen Kollektoren verarbeitet werden.

mapping()Die Methode ist wie folgt definiert:

public static <T, U, A, R> Collector<T, ?, R> mapping(
    Function<? super T, ? extends U> mapper,
    Collector<? super U, A, R> downstream)

In,

• mapper ist eine funktionale Schnittstelle zum Zuordnen jedes Elements im Stream;
• downstream Ist ein weiterer Kollektor für weitere Operationen an den zugeordneten Elementen.

  mapping()Die Methode wendet mapperdie Funktion auf die Elemente im Stream an und übergibt das Ergebnis downstreamzur weiteren Verarbeitung an den Kollektor. Abschließend werden die Ergebnisse zum Endergebnis zusammengefasst.

        Wir haben beispielsweise eine Liste mit Zeichenfolgen und möchten die Anzahl des Vorkommens von Zeichen in jeder Zeichenfolge zählen. Sie können mapping()die Methode verwenden, um jede Zeichenfolge einem MapObjekt mit der Anzahl der Vorkommen eines Zeichens zuzuordnen, und dann die Methode verwenden, um toMap()alle Mapzusammenzuführen , um das Endergebnis zu erhalten:

List<String> list = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

Map<Character, Integer> resultMap = list.stream()
    .flatMapToInt(String::chars)     // 将每个字符串转换为字符流
    .mapToObj(c -> (char) c)         // 将每个字符转换为包装类型
    .collect(Collectors.mapping(
        Function.identity(),         // 将字符作为 KEY
        Collectors.groupingBy(c -> c, Collectors.summingInt(c -> 1)) // 统计每个字符出现的次数
    ))
    .entrySet().stream()
    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

        Im obigen Code verwenden wir zunächst flatMapToInt()die Methode, um die Zeichenfolge in ein IntStreamObjekt zu konvertieren, und verwenden dann mapToObj()die Methode, um jedes Zeichen in einen Wrapper-Typ zu konvertieren. Dann verwenden wir mapping()die Methode, um jedes Zeichen zu gruppieren und zu zählen, mehrere Objekte abzurufen Mapund schließlich toMap()die Methode zu verwenden, um sie zu kombinieren, um das Endergebnis zu erhalten.

        Es ist zu beachten, dass mapping()wir in der Methode an den zweiten Parameter Collectors.groupingBy()die Methode übergeben, was bedeutet, dass wir die Elemente zuerst gruppiert haben. Der zweite groupingBy()Parameter der Methode ist Collectors.summingInt()die Methode, was bedeutet, dass wir für jede Gruppe von Elementen eine Summenoperation durchführen.

  Collectors.mapping()Die Methode ist sehr flexibel und kann in Verbindung mit anderen Kollektoren verwendet werden, um komplexere Datenverarbeitungsvorgänge zu erreichen

Partition

partitioningBy(Predicate<? super T> predicate)

        Collectors.partitioningBy(Predicate<? super T> predicate) ist ein Collector (Collector) in Java 8, der zum Partitionieren der Elemente im Stream gemäß den Bedingungen des Prädikats und zum Speichern des Partitionsergebnisses in einer Karte verwendet wird Objekt.

        Das Parameterprädikat dieser Methode ist ein Prädikat (Prädikat), das die Bedingung zum Filtern der Elemente im Stream darstellt, und sein Rückgabewert ist ein boolescher Typ. Insbesondere wenn die Methode „true“ zurückgibt, sollte das Element in die „true“-Liste der Partition einsortiert werden; wenn sie „false“ zurückgibt, sollte das Element in die „false“-Liste der Partition einsortiert werden.

        Angenommen, es gibt eine List<Student>-Studenten vom Typ Student, dann können wir die Methode Collectors.partitioningBy() verwenden, um sie danach zu partitionieren, ob die Punktzahl des Schülers größer oder gleich 60 ist, und das Partitionsergebnis in a speichern Kartenobjekt:

Map<Boolean, List<Student>> result = students.stream()
    .collect(Collectors.partitioningBy(s -> s.getScore() >= 60));

         Im obigen Code verwenden wir die Methode stream(), um die Liste in einen Stream zu konvertieren, verwenden dann die Methode Collectors.partitioningBy(), um die Elemente im Stream zu partitionieren, und speichern das Ergebnis der Partition im Ergebnis vom Typ Map <Boolean, List<Student>>-Objekt. Im resultierenden Map-Objekt enthält der Teil, dessen Schlüssel „true“ ist, alle Schüler, deren Punktzahl größer oder gleich 60 Punkten ist, und der Teil, dessen Schlüssel „false“ ist, alle Schüler, deren Punktzahl weniger als 60 Punkte beträgt.

        Wenn wir die Elemente im Stream nach einem bestimmten Attribut partitionieren müssen, können wir die Methodenreferenz anstelle des Lambda-Ausdrucks verwenden. Unter der Annahme, dass der Typ „Student“ beispielsweise über das boolesche Attribut isMale verfügt, das angibt, ob der Student männlich ist, können wir die Studenten mit dem folgenden Code aufteilen:

Map<Boolean, List<Student>> result = students.stream()
    .collect(Collectors.partitioningBy(Student::isMale));

        Im obigen Code stellt Student::isMale eine statische Methode im Typ Student dar, mit der zurückgegeben wird, ob der Student männlich ist. Daher können wir diese Methode als Prädikatparameter an die Methode Collectors.partitioningBy() übergeben, um die Funktion der Aufteilung der Schüler nach ihrem Geschlecht zu realisieren.

        Kurz gesagt, Collectors.partitioningBy(Predicate<? super T> predicate) ist ein sehr nützlicher Collector in Java 8, der die Elemente im Stream nach beliebigen Bedingungen partitionieren und das Ergebnis der Partition in einem Map-Objekt speichern kann bietet uns einen großen Komfort bei der Datenverarbeitung.

partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

        Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) ist ein Kollektor (Collector) in Java 8, der zum Partitionieren der Elemente in Stream gemäß den Bedingungen von Predicate verwendet wird. und wenden Sie einen Downstream-Kollektor (Downstream) auf jede Partition an und speichern Sie das Ergebnis der Partition in einem Map-Objekt.

        Das erste Parameterprädikat dieser Methode ist ein Prädikat (Prädikat), das die Bedingung zum Filtern der Elemente im Stream darstellt. Elemente, die die Bedingungen erfüllen, werden der wahren Liste der Partition zugewiesen; andernfalls werden sie der falschen Liste der Partition zugewiesen.

        Der zweite nachgeschaltete Parameter ist ein nachgeschalteter Kollektor (Collector), der auf die Elemente jeder Partition einwirkt. Der vom Downstream empfangene Typ ist T, der Typ des Zwischenakkumulationsergebnisses ist A und der endgültige Rückgabewerttyp ist D. Normalerweise verwenden wir andere Collectors als Downstream, wie Collectors.toList(), Collectors.toSet(), Collectors.summingInt() und andere Methoden.

        Im Folgenden erläutern wir anhand eines Beispiels die Verwendung von Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream). Angenommen, es gibt eine Liste „List<Person>“ für Personen vom Typ „Person“. Wir müssen Personen, deren Alter größer oder gleich 18 ist, nach Geschlecht unterteilen und die Namen der Personen in jeder Partition in einer Liste<String> speichern. Sie können den folgenden Code verwenden, um Folgendes zu erreichen:

Map<Boolean, List<String>> result = persons.stream()
    .collect(Collectors.partitioningBy(
        p -> p.getAge() >= 18,
        Collectors.mapping(Person::getName, Collectors.toList())));

        Im obigen Code verwenden wir die Methode stream(), um die Liste in einen Stream zu konvertieren, verwenden dann die Methode Collectors.partitioningBy(), um die Elemente im Stream zu partitionieren, und speichern die Partitionsergebnisse in Map<Boolean, List< Ergebnisobjekt vom Typ String>>. Unter diesen bedeutet der erste Parameter p -> p.getAge() >= 18 die Partitionierung von Personen, deren Alter größer oder gleich 18 ist, und der zweite Parameter Collectors.mapping(Person::getName, Collectors.toList()) Mittel zur Partitionierung Der Name jeder Person wird einer Liste zugeordnet, und diese Liste wird als Wert der Partition verwendet. Auf diese Weise können wir nach Alter und Geschlecht unterteilen und eine Liste mit den Namen der Personen in jeder Unterteilung erhalten.

        Kurz gesagt, Collectors.partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream) ist ein sehr nützlicher Collector in Java 8, der die Elemente im Stream nach beliebigen Bedingungen partitionieren und anwenden kann Ein Downstream-Kollektor für jede Partition und das Speichern des Ergebnisses der Partition in einem Map-Objekt, was uns eine große Bequemlichkeit bei der Datenverarbeitung bietet. Gleichzeitig können wir durch die Auswahl eines vernünftigen Downstream-Kollektors komplexere Partitionsvorgänge erreichen.