KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Collector — aangepaste mutable streamreductie

Collector<T, A, R> beschrijft hoe stream-elementen worden verzameld in een mutable toestand en omgezet in een resultaat. Lees meer over de collectorfuncties, vereisten voor parallelle verwerking en de betekenis van de eigenschappen in Java SE 21.

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

Syntax

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

Collector<T, A, R> beschrijft een mutable reductie die door Stream.collect wordt gebruikt: T is het element, A de accumulatietoestand en R het resultaat. Verwar de interface Collector niet met de klasse Collectors, die kant-en-klare collectors biedt. Reikwijdte: Java SE 21; de runtime van de repository en de productieomgeving zijn niet bevestigd.

Collector.supplier() retourneert een functie die een nieuwe mutable container maakt; Collector.accumulator() retourneert een functie die een element toevoegt; Collector.combiner() retourneert een functie die deeltoestanden samenvoegt; Collector.finisher() retourneert een functie die A omzet in R. Collector.of maakt een collector met deze functies. De overload zonder expliciete finisher heeft A = R en declareert automatisch IDENTITY_FINISH.

Collector.characteristics() retourneert een onveranderlijke verzameling van gedeclareerde eigenschappen. Collector.Characteristics.CONCURRENT staat gelijktijdige aanroepen van de accumulator op dezelfde container toe. Collector.Characteristics.UNORDERED betekent dat de volgorde van voorkomen niet behouden hoeft te blijven. Gedeelde gelijktijdige accumulatie vereist CONCURRENT en daarnaast UNORDERED of een ongeordende stream. Collector.Characteristics.IDENTITY_FINISH staat toe de finisher over te slaan: deze moet een identiteitstransformatie zijn en de cast van A naar R moet slagen. Vlaggen beschrijven garanties; ze bieden geen synchronisatie.

Combineren moet associatief zijn en consistent met accumulatie; het samenvoegen van een lege toestand mag het resultaat niet veranderen. Een collector zonder CONCURRENT kan parallel worden uitgevoerd: de bibliotheek isoleert deeltoestanden en combineert ze daarna. Deel niet één mutable container tussen aanroepen van de supplier.

Het voorbeeld behoudt de volgorde en gebruikt StringBuilder als A en String als R. Het declareert geen eigenschappen: StringBuilder ondersteunt geen gedeelde gelijktijdige accumulatie en de finisher verandert het type. Beide verzamelmethoden zouden ABC moeten afdrukken.

Voorbeelden

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

Resultaat

ABC
ABC
true

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen