Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Agrupamento e contagem concorrentes em Java

`Collectors.groupingByConcurrent` agrupa os elementos de um fluxo por chave e permite contá-los por categoria sem preservar a sua ordem de ocorrência.

Versão: Java SE 21

Sintaxe

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)

Em Java SE 21, o método estático Collectors.groupingByConcurrent do pacote java.util.stream cria um coletor para Stream.collect. A função classifier associa cada elemento de tipo T a uma chave de tipo K. O coletor também funciona com um fluxo sequencial e não torna o fluxo paralelo por si só.

A variante com apenas classifier produz um ConcurrentMap<K, List<T>>. Com classifier, downstream, o coletor a jusante reduz os elementos de cada grupo a um resultado de tipo D, produzindo um ConcurrentMap<K, D>. Por exemplo, Collectors.counting() devolve uma contagem de tipo Long para cada chave presente, sem criar listas de elementos.

Com classifier, mapFactory, downstream, a função de criação fornece um mapa novo e vazio de tipo M que implementa ConcurrentMap<K, D>. Por exemplo, ConcurrentSkipListMap::new permite percorrer as chaves por ordem, mas não repõe a ordem de entrada dentro dos grupos. Sem uma função de criação, a API não garante a implementação concreta, a mutabilidade nem a serialisabilidade do mapa. Um mapa concorrente não torna as listas da primeira sobrecarga seguras para acesso concorrente.

As três sobrecargas têm as características CONCURRENT e UNORDERED. Num fluxo paralelo, collect pode acumular resultados de forma concorrente num mapa partilhado mesmo que a origem seja ordenada; não é necessário chamar unordered(). O coletor não garante a ordem de ocorrência dos elementos dentro de cada grupo.

Collectors.groupingBy não é um coletor concorrente, mas funciona corretamente num fluxo paralelo: os mapas parciais são construídos em separado e depois combinados. Usa-o com um coletor a jusante que preserve a ordem, como toList(), se num fluxo ordenado for importante manter a ordem dentro de cada grupo. O agrupamento concorrente pode evitar a combinação de mapas parciais, mas não garante maior rapidez. Mede o desempenho com dados representativos.

Exemplos

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

Resultado

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

`Function.identity()` usa como chave a própria cadeia de caracteres da categoria. `Collectors.counting()` conta cada ocorrência. Depois de `collect` terminar, uma cópia num `TreeMap` ordena as chaves apenas para apresentação.

Lições relacionadas

  • Java · Lição 43 · Avançado · Versão: 2

Fontes