Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Collector.of: creare un collector personalizzato con quattro funzioni

Definisci un collector per stream che crea uno stato di lavoro, incorpora gli elementi, unisce i risultati parziali e produce il valore finale.

Versione: Java SE 21

Sintassi

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 è un metodo factory statico dell’interfaccia java.util.stream.Collector. Crea un collector da passare all’operazione terminale Stream.collect(collector). In Collector<T, A, R>, T è il tipo degli elementi in ingresso, A il tipo dello stato intermedio mutabile e R quello del risultato finale.

Nell’overload a quattro funzioni, il supplier crea un nuovo contenitore A vuoto a ogni chiamata; l’accumulator lo aggiorna con un elemento T senza restituire nulla; il combiner unisce due risultati parziali e restituisce lo stato combinato A; il finisher trasforma lo stato finale A in R. Dopo le funzioni si possono indicare flag opzionali di tipo Collector.Characteristics. Entrambi gli overload lanciano NullPointerException se un argomento è null.

Una riduzione parallela può riempire contenitori separati e poi unirli. La riduzione con e senza suddivisione dell’input deve produrre risultati equivalenti. Per un collector con il flag UNORDERED, risultati che differiscono solo per l’ordine possono comunque essere equivalenti. Unire un risultato parziale a un contenitore vuoto come secondo argomento deve dare un risultato equivalente. Non restituire dal supplier un contenitore mutabile condiviso e non impostare CONCURRENT a meno che l’accumulator possa aggiornare in sicurezza lo stesso contenitore da più thread contemporaneamente.

L’overload a tre funzioni non accetta un finisher: restituisce Collector<T, R, R> e imposta automaticamente IDENTITY_FINISH. È un flag, non un metodo chiamato Collector.identityFinish, e consente alla riduzione di saltare il finisher. Non impostarlo se il finisher esegue una trasformazione necessaria. Se vuoi solo concatenare testi nell’ordine in cui compaiono gli elementi, usa il collector predefinito Collectors.joining.

Esempi

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

Risultato

count=3, totalLength=9

L’array `long[]` contiene il numero di stringhe e la somma dei rispettivi valori di `String.length()`. Il `combiner` somma le celle corrispondenti e il `finisher` crea un record `Totals`. Con questi dati, sia uno stream parallelo sia uno sequenziale producono `count=3, totalLength=9`.

Lezioni correlate

  • Java · Lezione 45 · Intermedio · Versione: 2

Fonti