CKTIS / Java
Raggruppamento e conteggio concorrenti in Java
`Collectors.groupingByConcurrent` raggruppa gli elementi di uno stream per chiave e può contarli per categoria senza conservarne l’ordine di incontro.
Versione: Java SE 21
Sintassi
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)In Java SE 21, il metodo statico Collectors.groupingByConcurrent del package java.util.stream crea un collector da passare a Stream.collect. La funzione classifier associa a ogni elemento di tipo T una chiave di tipo K. Il collector funziona anche con uno stream sequenziale e da solo non rende parallelo lo stream.
Con il solo classifier, il risultato è una ConcurrentMap<K, List<T>>. Con classifier, downstream, il collector a valle riduce gli elementi di ogni gruppo a un risultato di tipo D, ottenendo una ConcurrentMap<K, D>. Per esempio, Collectors.counting() produce un conteggio di tipo Long per ogni chiave presente senza creare liste di elementi.
Con classifier, mapFactory, downstream, la funzione factory fornisce una nuova mappa vuota di tipo M che implementa ConcurrentMap<K, D>. Per esempio, ConcurrentSkipListMap::new permette di iterare sulle chiavi in ordine, ma non ripristina l’ordine di ingresso all’interno dei gruppi. Senza una factory, l’API non garantisce l’implementazione concreta, la mutabilità o la serializzabilità della mappa. Una mappa concorrente non rende thread-safe le liste del primo overload.
Tutti e tre gli overload sono CONCURRENT e UNORDERED. Su uno stream parallelo, collect può accumulare i risultati in modo concorrente in una mappa condivisa anche se la sorgente è ordinata; non serve chiamare unordered(). Il collector non garantisce l’ordine di incontro degli elementi all’interno di un gruppo.
Collectors.groupingBy non è un collector concorrente, ma funziona correttamente su uno stream parallelo: le mappe parziali vengono costruite separatamente e poi unite. Usalo con un collector a valle che preserva l’ordine, come toList(), se in uno stream ordinato conta l’ordine degli elementi all’interno di ogni gruppo. Il raggruppamento concorrente può evitare l’unione delle mappe parziali, ma non garantisce prestazioni migliori. Misura le prestazioni con dati rappresentativi.
Esempi
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));
}
}Risultato
{book=3, game=2, music=1}`Function.identity()` usa la stringa della categoria stessa come chiave. `Collectors.counting()` conta ogni occorrenza. Al termine di `collect`, una copia in una `TreeMap` ordina le chiavi solo per la visualizzazione.
Lezioni correlate
- Java · Lezione 43 · Avanzato · Versione: 2
Fonti
- Collectors (Java SE 21 & JDK 21) — groupingByConcurrent(Function)
- Collectors (Java SE 21 & JDK 21) — groupingByConcurrent(Function, Collector)
- Collectors (Java SE 21 & JDK 21) — groupingByConcurrent(Function, Supplier, Collector)
- Collectors (Java SE 21 & JDK 21) — counting()
- Collectors (Java SE 21 & JDK 21) — groupingBy(Function, Collector)
- Stream (Java SE 21 & JDK 21) — collect(Collector)
- java.util.stream (Java SE 21 & JDK 21) — Reduction, concurrency, and ordering