CKTIS / Java
Collectors: estatísticas sumárias e agrupamento concorrente
A classe java.util.stream.Collectors disponibiliza collectors para Stream.collect. Combine Collectors.groupingByConcurrent com Collectors.summarizingDouble para calcular estatísticas numéricas sumárias separadamente para cada grupo.
Versão: Java SE 21; repository runtime, production runtime not attested
Sintaxe
stream.collect(Collectors.summarizingDouble(mapper))
stream.collect(Collectors.groupingByConcurrent(classifier, Collectors.summarizingDouble(mapper)))java.util.stream.Collectors disponibiliza estratégias de redução reutilizáveis para a operação terminal Stream.collect. Os collectors podem ser compostos: um collector externo forma grupos, enquanto um collector a jusante calcula o resultado de cada grupo. Esta entrada diz respeito ao Java SE 21; o ambiente de execução de produção não está atestado.
Collectors.summarizingDouble(mapper) devolve um Collector<T, ?, DoubleSummaryStatistics>. Quando é utilizado com Stream.collect, o collector aplica mapper a cada elemento para obter um valor do tipo double. O resultado de collect é um objeto DoubleSummaryStatistics que contém a contagem, a soma, o mínimo, o máximo e a média. Para uma entrada vazia, a contagem, a soma e a média são zero, o mínimo é Double.POSITIVE_INFINITY e o máximo é Double.NEGATIVE_INFINITY. Os arredondamentos podem alterar a soma e a média; os valores NaN afetam as estatísticas.
Tanto Collectors.groupingByConcurrent(classifier) como a sobrecarga com um collector a jusante devolvem um collector. Ao utilizar o primeiro com Stream.collect, obtém-se um ConcurrentMap<K, List<T>>; com o segundo, obtém-se um ConcurrentMap<K, D>. Ambos os collectors são concorrentes e têm a característica UNORDERED: não garantem que se mantenha a ordem pela qual os elementos são encontrados, mas essa ordem pode manter-se. Por exemplo, numa recolha sequencial, os elementos da lista de cada grupo podem ficar pela ordem em que foram encontrados. Em contrapartida, groupingBy não é um collector concorrente. Não há garantia de segurança entre threads para as próprias listas resultantes.
A redução concorrente requer um stream paralelo; o collector, por si só, não inicia um. As funções devem ser sem estado e não modificar a origem. Um mapa concorrente não torna seguras entre threads as alterações posteriores aos respetivos valores DoubleSummaryStatistics. O exemplo ordena as chaves apenas antes da impressão; os valores pequenos e representáveis exatamente tornam as estatísticas previsíveis.
Exemplos
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()));
}
}Resultado
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
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.