Les différences entre les Collectionneurs.toMap() et des Collectionneurs.groupingBy() pour recueillir une partie de la Carte

TLDR :

De recueillir dans un Map qui contient une seule valeur par clé (Map<MyKey,MyObject>), l'utilisation Collectionneurs.toMap().

Pour recueillir dans un Map qui contient plusieurs valeurs par clé (Map<MyKey, List<MyObject>>), l'utilisation Collectionneurs.groupingBy().

---

Collectionneurs.toMap()

Par écrit :

chargePoints.stream().collect(Collectors.toMap(Point::getParentId, c -> c));

L'objet retourné sera le Map<Long,Point> type.

Regardez les Collectors.toMap() la fonction que vous utilisez :

Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
                                    Function<? super T, ? extends U> valueMapper)

Elle renvoie une Collector avec comme résultat Map<K,U> où K et U sont le type de retour de deux fonctions passés à la méthode.
Dans votre cas, Point::getParentId est une Longue et c se réfère à un Point.
Alors que la Map<Long,Point> retourné lorsque collect() est appliquée.

Et ce comportement est plutôt attendu que Des collectionneurs.toMap() javadoc états :

renvoie une Collector qui accumule les éléments dans un Map dont les clés et valeurs
sont le résultat de l'application de la condition de la cartographie des fonctions à l'entrée
éléments.

Mais si les touches repérées contient des doublons (selon Object.equals(Object)), un IllegalStateException est jeté

Il sera probablement votre cas comme vous pourrez le groupe de la Points selon une propriété spécifique : parentId.

Si les touches repérées peuvent avoir des doublons, vous pouvez utiliser le toMap(fonction, Fonction, BinaryOperator) surcharge, mais il ne sera pas vraiment à résoudre votre problème car il ne sera pas des éléments du groupe avec le même parentId. Il sera juste fournir un moyen de ne pas avoir deux éléments avec le même parentId.

---

Collectionneurs.groupingBy()

Pour atteindre votre condition, vous devez utiliser Collectionneurs.groupingBy() dont le comportement et la déclaration de la méthode convient beaucoup mieux à votre besoin :

public static <T, K> Collector<T, ?, Map<K, List<T>>>
groupingBy(Function<? super T, ? extends K> classifier) 

Il est précisé que :

Retourne un Collecteur de mise en œuvre d'un "groupe" de l'opération sur entrée
les éléments de type T, le groupement d'éléments selon un classement
la fonction, et de renvoyer les résultats sur une Carte.

La méthode prend un Function.

Dans votre cas, le Function paramètre est Point (le type de Flux), et vous retournez Point.getParentId() que vous souhaitez grouper les éléments par parentId valeurs.

De sorte que vous pourriez écrire :

Map<Long, List<Point>> pointByParentId = 
                       chargePoints.stream()
                                   .collect(Collectors.groupingBy( p -> p.getParentId())); 

Ou avec une méthode de référence :

Map<Long, List<Point>> pointByParentId = 
                       chargePoints.stream()
                                   .collect(Collectors.groupingBy(Point::getParentId));

---

Collectionneurs.groupingBy() : aller plus loin

En effet, le groupingBy() collecteur va plus loin que l'exemple réel.
Le Collectors.groupingBy(Function<? super T, ? extends K> classifier) méthode est finalement juste une méthode pratique pour stocker les valeurs de la collecte des Map dans un List.

Pour stocker des valeurs de la Map dans autre chose qu'un List ou pour stocker le résultat d'un calcul spécifique , groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream) devrait vous intéresser.

Par exemple :

Map<Long, Set<Point>> pointByParentId = 
                       chargePoints.stream()
                                   .collect(Collectors.groupingBy(Point::getParentId, toSet()));

Donc au-delà de la question posée, vous devriez envisager de groupingBy() comme un moyen souple de choisir des valeurs que vous souhaitez stocker dans le collectées Map, ce définitivement toMap() ne l'est pas.

OriginalL'auteur davidxxx

Le code suivant fait les choses. Collectors.toList() est celui par défaut, de sorte que vous pouvez ignorer, mais dans le cas où vous voulez avoir Map<Long, Set<Point>> Collectors.toSet() serait nécessaire.

Map<Long, List<Point>> map = pointList.stream()
                .collect(Collectors.groupingBy(Point::getParentId, Collectors.toList()));

OriginalL'auteur xenteros