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

CKTIS / Java

Collectors : statistiques récapitulatives et regroupement concurrent

La classe java.util.stream.Collectors fournit des collecteurs pour Stream.collect. Combinez Collectors.groupingByConcurrent et Collectors.summarizingDouble pour calculer des statistiques numériques récapitulatives séparément pour chaque groupe.

Version : Java SE 21; repository runtime, production runtime not attested

Syntaxe

stream.collect(Collectors.summarizingDouble(mapper))
stream.collect(Collectors.groupingByConcurrent(classifier, Collectors.summarizingDouble(mapper)))

java.util.stream.Collectors fournit des stratégies de réduction réutilisables pour l’opération terminale Stream.collect. Les collecteurs peuvent être combinés : un collecteur externe forme les groupes, tandis qu’un collecteur aval calcule le résultat de chaque groupe. Cette fiche concerne Java SE 21 ; l’environnement d’exécution en production n’est pas attesté.

Collectors.summarizingDouble(mapper) renvoie un Collector<T, ?, DoubleSummaryStatistics>. Lorsqu’il est utilisé avec Stream.collect, ce collecteur applique mapper à chaque élément pour obtenir une valeur de type double. Le résultat de collect est un objet DoubleSummaryStatistics qui contient le nombre d’éléments, la somme, le minimum, le maximum et la moyenne. Pour une entrée vide, le nombre, la somme et la moyenne valent zéro, le minimum est Double.POSITIVE_INFINITY et le maximum est Double.NEGATIVE_INFINITY. Les arrondis peuvent modifier la somme et la moyenne ; les valeurs NaN influent sur les statistiques.

Collectors.groupingByConcurrent(classifier) et la surcharge avec un collecteur aval renvoient chacun un collecteur. Utilisé avec Stream.collect, le premier produit une ConcurrentMap<K, List<T>> et le second une ConcurrentMap<K, D>. Ces deux collecteurs sont concurrents et ont la caractéristique UNORDERED : ils ne garantissent pas la conservation de l’ordre de rencontre des éléments, mais cet ordre peut être conservé. Par exemple, lors d’une collecte séquentielle, les éléments de la liste de chaque groupe peuvent rester dans leur ordre de rencontre. En revanche, groupingBy n’est pas un collecteur concurrent. La sécurité des threads n’est pas garantie pour les listes obtenues elles-mêmes.

La réduction concurrente nécessite un flux parallèle ; le collecteur seul n’en démarre pas un. Les fonctions doivent être sans état et ne pas modifier la source. Une map concurrente ne rend pas sûres vis-à-vis des threads les modifications ultérieures de ses valeurs DoubleSummaryStatistics. L’exemple ne trie les clés qu’avant l’affichage ; ses petites valeurs représentables exactement rendent les statistiques prévisibles.

Exemples

import java.util.DoubleSummaryStatistics;
import java.util.List;
import java.util.Locale;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentMap;
import java.util.stream.Collectors;

public class Main {
    record Item(String category, double value) {}

    public static void main(String[] args) {
        var items = List.of(
            new Item("A", 2.0),
            new Item("B", 8.0),
            new Item("A", 4.0)
        );

        ConcurrentMap<String, DoubleSummaryStatistics> stats =
            items.parallelStream().collect(Collectors.groupingByConcurrent(
                Item::category,
                Collectors.summarizingDouble(Item::value)
            ));

        new TreeMap<>(stats).forEach((category, s) ->
            System.out.printf(Locale.ROOT,
                "%s: count=%d sum=%.1f min=%.1f max=%.1f avg=%.1f%n",
                category, s.getCount(), s.getSum(), s.getMin(),
                s.getMax(), s.getAverage()));
    }
}

Résultat

A: count=2 sum=6.0 min=2.0 max=4.0 avg=3.0
B: count=1 sum=8.0 min=8.0 max=8.0 avg=8.0

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources