Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Regroupement et comptage concurrents en Java

`Collectors.groupingByConcurrent` regroupe les éléments d’un flux par clé et peut les compter par catégorie sans préserver leur ordre de rencontre.

Version : Java SE 21

Syntaxe

Declared in java.util.stream.Collectors:
public static <T, K> Collector<T, ?, ConcurrentMap<K, List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier)
public static <T, K, A, D> Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
public static <T, K, A, D, M extends ConcurrentMap<K, D>> Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)

Dans Java SE 21, la méthode statique Collectors.groupingByConcurrent du paquet java.util.stream crée un collecteur à passer à Stream.collect. La fonction classifier associe à chaque élément de type T une clé de type K. Le collecteur fonctionne aussi sur un flux séquentiel et ne rend pas le flux parallèle à lui seul.

Avec classifier seul, le résultat est une ConcurrentMap<K, List<T>>. Avec classifier, downstream, le collecteur aval réduit les éléments de chaque groupe en un résultat de type D, ce qui donne une ConcurrentMap<K, D>. Par exemple, Collectors.counting() fournit un total de type Long pour chaque clé présente, sans construire de listes d’éléments.

Avec classifier, mapFactory, downstream, la fabrique fournit une nouvelle map vide de type M qui implémente ConcurrentMap<K, D>. Par exemple, ConcurrentSkipListMap::new permet de parcourir les clés dans l’ordre de tri, mais ne rétablit pas l’ordre d’entrée au sein des groupes. Sans fabrique, l’API ne garantit ni l’implémentation concrète de la map, ni sa mutabilité, ni sa sérialisabilité. Une map concurrente ne rend pas les listes de la première surcharge sûres pour les accès concurrents.

Les trois surcharges sont CONCURRENT et UNORDERED. Sur un flux parallèle, collect peut accumuler les résultats de façon concurrente dans une map partagée, même si la source est ordonnée ; inutile d’appeler unordered(). Le collecteur ne garantit pas l’ordre de rencontre des éléments au sein d’un groupe.

Collectors.groupingBy n’est pas un collecteur concurrent, mais fonctionne correctement sur un flux parallèle : les maps partielles sont construites séparément puis fusionnées. Utilisez-le avec un collecteur aval qui préserve l’ordre, comme toList(), si l’ordre des éléments dans chaque groupe compte pour un flux ordonné. Le regroupement concurrent peut éviter la fusion des maps partielles, mais ne garantit aucun gain de vitesse. Mesurez les performances sur des données représentatives.

Exemples

import java.util.List;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentMap;
import java.util.function.Function;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> categories = List.of("book", "game", "book", "music", "game", "book");

        ConcurrentMap<String, Long> counts = categories.parallelStream()
                .collect(Collectors.groupingByConcurrent(
                        Function.identity(), Collectors.counting()));

        System.out.println(new TreeMap<>(counts));
    }
}

Résultat

{book=3, game=2, music=1}

`Function.identity()` utilise la chaîne de catégorie elle-même comme clé. `Collectors.counting()` compte chaque occurrence. Une fois `collect` terminé, une copie dans une `TreeMap` trie les clés uniquement pour l’affichage.

Leçons associées

  • Java · Leçon 43 · Avancé · Version : 2

Sources