Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Collector — riduzione mutabile personalizzata degli stream

Collector<T, A, R> descrive come accumulare gli elementi di uno stream in uno stato mutabile e trasformarlo in un risultato. Scopri le funzioni del collector, i requisiti per l’elaborazione parallela e il significato delle sue caratteristiche in Java SE 21.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

Collector<T, A, R>
Collector.of(supplier, accumulator, combiner, characteristics...)
Collector.of(supplier, accumulator, combiner, finisher, characteristics...)

Collector<T, A, R> descrive una riduzione mutabile usata da Stream.collect: T è l’elemento, A lo stato di accumulazione e R il risultato. Non confondere l’interfaccia Collector con la classe Collectors, che fornisce collector già pronti. Ambito: Java SE 21; l’ambiente di runtime del repository e quello di produzione non sono attestati.

Collector.supplier() restituisce una funzione che crea un nuovo contenitore mutabile; Collector.accumulator() restituisce una funzione che incorpora un elemento; Collector.combiner() restituisce una funzione che unisce stati parziali; Collector.finisher() restituisce una funzione che converte A in R. Collector.of crea un collector a partire da queste funzioni. L’overload senza finisher esplicito ha A = R e dichiara automaticamente IDENTITY_FINISH.

Collector.characteristics() restituisce un insieme immutabile delle proprietà dichiarate. Collector.Characteristics.CONCURRENT consente chiamate simultanee dell’accumulator sullo stesso contenitore. Collector.Characteristics.UNORDERED significa che non vi è l’impegno a preservare l’ordine di incontro. L’accumulazione concorrente condivisa richiede CONCURRENT e UNORDERED oppure uno stream non ordinato. Collector.Characteristics.IDENTITY_FINISH consente di saltare il finisher: deve essere una trasformazione identità e il cast da A a R deve riuscire. I flag descrivono garanzie; non forniscono sincronizzazione.

La combinazione deve essere associativa e coerente con l’accumulazione; unire uno stato vuoto non deve cambiare il risultato. Un collector senza CONCURRENT può essere eseguito in parallelo: la libreria isola gli stati parziali e poi li combina. Non condividere un unico contenitore mutabile tra le chiamate del supplier.

L’esempio conserva l’ordine e usa StringBuilder come A e String come R. Non dichiara caratteristiche: StringBuilder non supporta l’accumulazione concorrente condivisa e il finisher cambia il tipo. Ci si aspetta che entrambi i percorsi di raccolta stampino ABC.

Esempi

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

public class Main {
    public static void main(String[] args) {
        Collector<String, StringBuilder, String> concatenate = Collector.of(
            StringBuilder::new,
            (buffer, value) -> buffer.append(value),
            (left, right) -> { left.append(right); return left; },
            StringBuilder::toString
        );
        List<String> values = List.of("A", "B", "C");
        System.out.println(values.stream().collect(concatenate));
        System.out.println(values.parallelStream().collect(concatenate));
        System.out.println(concatenate.characteristics().isEmpty());
    }
}

Risultato

ABC
ABC
true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti