KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Collector.of: maak een eigen collector met vier functies

Definieer een streamcollector die een werktoestand aanmaakt, elementen verwerkt, deelresultaten samenvoegt en de eindwaarde oplevert.

Versie: Java SE 21

Syntax

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 is een statische fabrieksmethode van de interface java.util.stream.Collector. De methode maakt een collector die je doorgeeft aan de terminale bewerking Stream.collect(collector). In Collector<T, A, R> is T het type van de invoerelementen, A het type van de veranderlijke tussentoestand en R het type van het eindresultaat.

Bij de overload met vier functies maakt de supplier bij elke aanroep een nieuwe, lege container A; de accumulator werkt die bij met één element T en geeft niets terug; de combiner voegt twee deelresultaten samen en geeft de gecombineerde toestand A terug; de finisher zet de uiteindelijke toestand A om in R. Na de functies kun je optionele vlaggen van het type Collector.Characteristics meegeven. Beide overloads geven een NullPointerException als een argument null is.

Een parallelle reductie kan afzonderlijke containers vullen en die daarna samenvoegen. Reductie met en zonder opsplitsing van de invoer moet gelijkwaardige resultaten opleveren. Bij een collector met UNORDERED kunnen resultaten die alleen in volgorde verschillen toch gelijkwaardig zijn. Samenvoegen van een deelresultaat met een lege container als tweede argument moet een gelijkwaardig resultaat geven. Laat de supplier geen gedeelde, veranderlijke container teruggeven en zet CONCURRENT alleen als de accumulator dezelfde container veilig vanuit meerdere threads tegelijk kan bijwerken.

De overload met drie functies neemt geen finisher aan: deze geeft Collector<T, R, R> terug en zet automatisch IDENTITY_FINISH. Dat is een vlag, geen methode met de naam Collector.identityFinish. De reductie mag daardoor de finisher overslaan. Zet de vlag niet als de finisher een noodzakelijke omzetting doet. Wil je alleen tekst samenvoegen in de volgorde waarin de elementen voorkomen, gebruik dan de ingebouwde collector Collectors.joining.

Voorbeelden

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

Resultaat

count=3, totalLength=9

De array `long[]` bevat het aantal strings en de som van hun `String.length()`-waarden. De `combiner` telt de overeenkomstige posities op en de `finisher` maakt een `Totals`-record. Zowel een parallelle als een sequentiële stream geeft voor deze invoer `count=3, totalLength=9`.

Gerelateerde lessen

  • Java · Les 45 · Gemiddeld · Versie: 2

Bronnen