Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / Java

Collectors: statystyki i grupowanie współbieżne

Klasa java.util.stream.Collectors udostępnia kolektory dla Stream.collect. Połącz Collectors.groupingByConcurrent z Collectors.summarizingDouble, aby obliczać statystyki liczbowe osobno dla każdej grupy.

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

Składnia

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

java.util.stream.Collectors dostarcza gotowe strategie redukcji dla operacji terminalnej Stream.collect. Kolektory można składać: kolektor zewnętrzny tworzy grupy, a kolektor podrzędny oblicza wynik każdej grupy. Zakres wpisu to Java SE 21; środowisko produkcyjne nie zostało potwierdzone.

Collectors.summarizingDouble(mapper) zwraca Collector<T, ?, DoubleSummaryStatistics>. Użyty w Stream.collect, kolektor stosuje mapper do każdego elementu, aby uzyskać wartość typu double. Wynikiem operacji jest DoubleSummaryStatistics zawierający liczbę elementów, sumę, minimum, maksimum i średnią. Dla pustego wejścia liczność, suma i średnia wynoszą zero, minimum to Double.POSITIVE_INFINITY, a maksimum to Double.NEGATIVE_INFINITY. Zaokrąglenia mogą zmieniać sumę i średnią; wartości NaN wpływają na statystyki.

Collectors.groupingByConcurrent(classifier) i wariant z kolektorem podrzędnym zwracają kolektory. Użycie pierwszego w Stream.collect daje ConcurrentMap<K, List<T>>, a użycie drugiego daje ConcurrentMap<K, D>. Oba kolektory są współbieżne i mają cechę UNORDERED: nie gwarantują zachowania kolejności napotkania elementów, ale jej nie wykluczają. Na przykład przy sekwencyjnym zbieraniu elementy na liście każdej grupy mogą pozostać w kolejności napotkania. W przeciwieństwie do nich groupingBy nie jest kolektorem współbieżnym. Same listy w wyniku nie mają gwarancji bezpieczeństwa wątkowego.

Współbieżna redukcja wymaga strumienia równoległego; sam kolektor go nie uruchamia. Funkcje powinny być bezstanowe i nie modyfikować źródła. Mapa współbieżna nie zapewnia bezpieczeństwa późniejszych modyfikacji obiektów DoubleSummaryStatistics. Przykład sortuje klucze dopiero przed wypisaniem; małe, dokładnie reprezentowalne wartości zapewniają przewidywalne statystyki.

Przykłady

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

Wynik

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

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła