Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Collectors: statistiche riepilogative e raggruppamento concorrente

La classe java.util.stream.Collectors fornisce collector per Stream.collect. Combina Collectors.groupingByConcurrent con Collectors.summarizingDouble per calcolare statistiche numeriche riepilogative separatamente per ogni gruppo.

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

Sintassi

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

java.util.stream.Collectors fornisce strategie di riduzione riutilizzabili per l’operazione terminale Stream.collect. I collector possono essere composti: un collector esterno forma i gruppi, mentre un collector downstream calcola il risultato di ciascun gruppo. Questa voce riguarda Java SE 21; l’ambiente di esecuzione in produzione non è attestato.

Collectors.summarizingDouble(mapper) restituisce un Collector<T, ?, DoubleSummaryStatistics>. Quando viene usato con Stream.collect, il collector applica mapper a ciascun elemento per ottenere un valore di tipo double. Il risultato di collect è un oggetto DoubleSummaryStatistics che contiene il conteggio, la somma, il minimo, il massimo e la media. Per un input vuoto, conteggio, somma e media sono zero, il minimo è Double.POSITIVE_INFINITY e il massimo è Double.NEGATIVE_INFINITY. Gli arrotondamenti possono modificare la somma e la media; i valori NaN influiscono sulle statistiche.

Sia Collectors.groupingByConcurrent(classifier) sia l’overload con un collector downstream restituiscono un collector. Usato con Stream.collect, il primo produce una ConcurrentMap<K, List<T>>, il secondo una ConcurrentMap<K, D>. Entrambi i collector sono concorrenti e hanno la caratteristica UNORDERED: non garantiscono che l’ordine di incontro degli elementi venga mantenuto, ma non lo escludono. Ad esempio, con una raccolta sequenziale gli elementi nella lista di ciascun gruppo possono rimanere nell’ordine di incontro. Al contrario, groupingBy non è un collector concorrente. Non è garantita la sicurezza dei thread per le liste risultanti.

La riduzione concorrente richiede uno stream parallelo; il collector da solo non ne avvia uno. Le funzioni devono essere senza stato e non modificare la sorgente. Una mappa concorrente non rende thread-safe le successive modifiche ai suoi valori DoubleSummaryStatistics. L’esempio ordina le chiavi solo prima della stampa; i valori piccoli e rappresentabili esattamente rendono prevedibili le statistiche.

Esempi

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()));
    }
}

Risultato

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

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti