Comment effectuer un regroupement imbriqué basé sur plusieurs propriétés dans Java 8

Regroupement imbriqué dans Java 8 pour les structures d'objets complexes

Dans Java 8, la méthode Collectors.groupingBy fournit un moyen puissant de regrouper des éléments en fonction sur des propriétés spécifiques. Cela vous permet de regrouper et de résumer efficacement les données. Cependant, qu'en est-il des scénarios dans lesquels vous avez plusieurs niveaux de regroupement à effectuer ?

Considérez la structure de classe suivante :

<code class="java">class Pojo {
    List<Item> items;
}

class Item {
    T key1;
    List<SubItem> subItems;
}

class SubItem {
    V key2;
    Object otherAttribute1;
}</code>

L'objectif est de regrouper les éléments en fonction de la clé 1 puis, pour chacun groupe d'éléments, regroupez d'autres sous-éléments en fonction de key2. Le résultat souhaité est une carte du formulaire :

<code class="java">Map<T, Map<V, List<SubItem>>></code>

L'utilisation standard de Collectors.groupingBy ne suffira pas pour ce scénario. Le défi réside dans le regroupement d'un seul élément par plusieurs clés.

Solution : Aplatir la structure

La clé pour résoudre ce problème est d'aplatir temporairement la structure. Ce faisant, vous pouvez créer un flux de combinaisons d'éléments et de sous-éléments avant d'effectuer les regroupements nécessaires.

Une approche consiste à utiliser la méthode Stream.flatMap pour créer un flux d'objets Map.Entry, où chaque entrée représente une paire d'Item et SubItem :

<code class="java">Map<T, Map<V, List<SubItem>>> result = pojo.getItems().stream()
    .flatMap(item -> item.subItems.stream()
        .map(sub -> new AbstractMap.SimpleImmutableEntry<> (item.getKey1(), sub)))
    .collect(Collectors.groupingBy(AbstractMap.SimpleImmutableEntry::getKey,
                Collectors.mapping(Map.Entry::getValue,
                    Collectors.groupingBy(SubItem::getKey2))));</code>

Solution alternative avec Collectors.flatMapping (Java 9)

En Java 9 et supérieur, une approche plus élégante est disponible à l'aide du collecteur Collectors.flatMapping :

<code class="java">Map<T, Map<V, List<SubItem>>> result = pojo.getItems().stream()
    .collect(Collectors.groupingBy(Item::getKey1,
                Collectors.flatMapping(item -> item.getSubItems().stream(),
                    Collectors.groupingBy(SubItem::getKey2))));</code>

Conclusion

En tirant parti des flux, des collecteurs et de l'aplatissement temporaire des objets, il est possible d'obtenir un regroupement imbriqué même pour structures d'objets complexes dans Java 8 et au-delà.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!