Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Collector.of: vlastní kolektor se čtyřmi funkcemi

Vytvořte vlastní kolektor proudu, který založí pracovní stav, přidává prvky, slučuje dílčí výsledky a převede stav na konečnou hodnotu.

Verze: Java SE 21

Syntaxe

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 je statická tovární metoda rozhraní java.util.stream.Collector. Vytváří kolektor, který předáte koncové operaci Stream.collect(collector). V typu Collector<T, A, R> označuje T typ vstupních prvků, A typ měnitelného mezistavu a R typ konečného výsledku.

V přetížení se čtyřmi funkcemi supplier při každém volání vytvoří nový prázdný kontejner typu A; accumulator ho aktualizuje o jeden prvek typu T a nic nevrací; combiner sloučí dva dílčí výsledky a vrátí sloučený stav typu A; finisher převede výsledný stav typu A na typ R. Za funkcemi lze uvést nepovinné příznaky typu Collector.Characteristics. Obě přetížení vyvolají NullPointerException, pokud má některý argument hodnotu null.

Při paralelní redukci se mohou naplnit oddělené kontejnery a následně sloučit. Redukce s rozdělením vstupu i bez něj musí dát rovnocenné výsledky. U kolektoru s příznakem UNORDERED mohou být výsledky rovnocenné, i když se liší pouze pořadím. Sloučení dílčího výsledku s prázdným kontejnerem jako druhým argumentem musí dát rovnocenný výsledek. Z supplier nevracejte sdílený měnitelný kontejner a příznak CONCURRENT nastavte jen tehdy, když accumulator dokáže bezpečně aktualizovat tentýž kontejner z více vláken současně.

Přetížení se třemi funkcemi nepřijímá finisher: vrací Collector<T, R, R> a automaticky nastavuje IDENTITY_FINISH. Je to příznak, nikoli metoda Collector.identityFinish; redukce díky němu může přeskočit finisher. Nenastavujte ho, pokud finisher provádí potřebnou transformaci. Pokud chcete pouze spojovat texty v pořadí, v jakém se prvky v proudu vyskytují, použijte hotový kolektor Collectors.joining.

Příklady

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

Výsledek

count=3, totalLength=9

Pole `long[]` obsahuje počet řetězců a součet hodnot `String.length()`. `combiner` sečte odpovídající položky a `finisher` vytvoří záznam `Totals`. Paralelní i sekvenční proud pro tento vstup vrátí `count=3, totalLength=9`.

Související lekce

  • Java · Lekce 45 · Středně pokročilá · Verze: 2

Zdroje