Comment effectuer des opérations GroupBy imbriquées dans Java 8 pour l'agrégation de données complexes ?

GroupBy imbriqué (à plusieurs niveaux) dans Java 8

Le regroupement à plusieurs niveaux dans Java 8 permet une agrégation complexe d'objets de données basés sur plusieurs champs. Dans votre cas, vous disposez d'un ensemble de classes Pojo, Item et SubItem, et vous souhaitez regrouper les éléments en fonction de la clé1, puis les sous-éléments de ce groupe par la clé2.

Pour y parvenir, nous ne pouvons pas simplement utilisez des appels Collectors.groupingBy imbriqués, car cela ne permettrait pas le regroupement par plusieurs clés à partir de différents objets. Au lieu de cela, nous recourons à une combinaison de flatMap et de collecteurs de regroupement :

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

Dans cette approche, nous utilisons d'abord flatMap pour créer un flux de paires contenant la clé1 de chaque élément et le sous-élément correspondant. Ensuite, nous appliquons Collectors.groupingBy deux fois : une fois pour regrouper les paires par clé1 et une autre fois pour regrouper les sous-éléments par clé2.

Une solution alternative serait de définir un collecteur personnalisé qui fournit une opération flatMapping similaire à celle de Java 9. Collectors.flatMapping :

<code class="java">static <T,U,A,R> Collector<T,?,R> flatMapping(
    Function<? super T,? extends Stream<? extends U>> mapper,
    Collector<? super U,A,R> downstream) {

    BiConsumer<A, ? super U> acc = downstream.accumulator();
    return Collector.of(downstream.supplier(),
        (a, t) -> { try(Stream<? extends U> s=mapper.apply(t)) {
            if(s!=null) s.forEachOrdered(u -> acc.accept(a, u));
        }},
        downstream.combiner(), downstream.finisher(),
        downstream.characteristics().toArray(new Collector.Characteristics[0]));
}</code>

Avec ce collecteur personnalisé, l'opération de regroupement peut être simplifiée :

<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>

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!