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

CKTIS / Java

Collector.of: criar um coletor personalizado com quatro funções

Define um coletor para streams que cria um estado de trabalho, incorpora elementos, combina resultados parciais e produz o valor final.

Versão: Java SE 21

Sintaxe

import java.util.stream.Collector;

// Static overloads declared by java.util.stream.Collector:
static <T, A, R> Collector<T, A, R> of(
    Supplier<A> supplier, BiConsumer<A, T> accumulator,
    BinaryOperator<A> combiner, Function<A, R> finisher,
    Collector.Characteristics... characteristics);

static <T, R> Collector<T, R, R> of(
    Supplier<R> supplier, BiConsumer<R, T> accumulator,
    BinaryOperator<R> combiner,
    Collector.Characteristics... characteristics);

Collector.of é um método de fábrica estático da interface java.util.stream.Collector. Cria um coletor para passar à operação terminal Stream.collect(collector). Em Collector<T, A, R>, T é o tipo dos elementos de entrada, A o do estado intermédio mutável e R o do resultado final.

Na sobrecarga com quatro funções, supplier cria um contentor A novo e vazio em cada chamada; accumulator atualiza-o com um elemento T sem devolver nada; combiner junta dois resultados parciais e devolve o estado combinado A; e finisher transforma o estado final A em R. Depois das funções podem indicar-se opções de tipo Collector.Characteristics. Ambas as sobrecargas lançam NullPointerException se um argumento for null.

Uma redução paralela pode preencher contentores separados e juntá-los depois. A redução com e sem divisão dos dados de entrada tem de produzir resultados equivalentes. Num coletor com a característica UNORDERED, os resultados podem ser equivalentes mesmo que difiram apenas na ordem. Combinar um resultado parcial com um contentor vazio como segundo argumento tem de produzir um resultado equivalente. Não devolvas um contentor mutável partilhado a partir de supplier e não indiques CONCURRENT, a menos que accumulator possa atualizar o mesmo contentor em segurança a partir de várias threads em simultâneo.

A sobrecarga com três funções não recebe finisher: devolve Collector<T, R, R> e define automaticamente IDENTITY_FINISH. É uma característica, não um método chamado Collector.identityFinish, e permite à redução prescindir de finisher. Não a definas se finisher fizer uma transformação necessária. Se apenas quiseres concatenar textos pela ordem em que os elementos aparecem, usa o coletor predefinido Collectors.joining.

Exemplos

import java.util.List;
import java.util.stream.Collector;

public class Main {
    record Totals(long count, long totalLength) {}

    public static void main(String[] args) {
        Collector<String, long[], Totals> lengthTotals = Collector.of(
            () -> new long[2],
            (state, word) -> {
                state[0]++;
                state[1] += word.length();
            },
            (left, right) -> {
                left[0] += right[0];
                left[1] += right[1];
                return left;
            },
            state -> new Totals(state[0], state[1])
        );

        Totals totals = List.of("ant", "bear", "ox")
            .parallelStream()
            .collect(lengthTotals);
        System.out.println("count=" + totals.count()
            + ", totalLength=" + totals.totalLength());
    }
}

Resultado

count=3, totalLength=9

O array `long[]` guarda o número de cadeias de caracteres e a soma dos respetivos valores de `String.length()`. `combiner` soma as posições correspondentes e `finisher` cria um record `Totals`. Para estes dados, tanto um stream paralelo como um sequencial produzem `count=3, totalLength=9`.

Lições relacionadas

  • Java · Lição 45 · Intermédio · Versão: 2

Fontes