Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Collector.of : créer un collecteur personnalisé avec quatre fonctions

Définissez un collecteur de flux qui crée un état de travail, y ajoute les éléments, fusionne les résultats partiels et produit la valeur finale.

Version : 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 est une méthode de fabrique statique de l’interface java.util.stream.Collector. Elle crée un collecteur à passer à l’opération terminale Stream.collect(collector). Dans Collector<T, A, R>, T est le type des éléments d’entrée, A celui de l’état intermédiaire modifiable et R celui du résultat final.

Dans la surcharge à quatre fonctions, le supplier crée un conteneur A neuf et vide à chaque appel ; l’accumulator le met à jour avec un élément T sans rien renvoyer ; le combiner fusionne deux résultats partiels et renvoie l’état combiné A ; le finisher transforme l’état final A en R. Des indicateurs facultatifs de type Collector.Characteristics peuvent suivre les fonctions. Les deux surcharges lèvent NullPointerException si un argument vaut null.

Une réduction parallèle peut remplir des conteneurs distincts avant de les fusionner. La réduction avec et sans découpage de l’entrée doit produire des résultats équivalents. Pour un collecteur portant l’indicateur UNORDERED, des résultats qui ne diffèrent que par l’ordre peuvent néanmoins être équivalents. Fusionner un résultat partiel avec un conteneur vide en deuxième argument doit donner un résultat équivalent. Ne faites pas renvoyer un conteneur modifiable partagé par le supplier. N’activez CONCURRENT que si l’accumulator peut mettre à jour sans risque le même conteneur depuis plusieurs threads simultanément.

La surcharge à trois fonctions ne prend pas de finisher : elle renvoie Collector<T, R, R> et définit automatiquement IDENTITY_FINISH. C’est un indicateur, pas une méthode Collector.identityFinish ; la réduction peut ainsi omettre le finisher. Ne le définissez pas si le finisher effectue une transformation nécessaire. Si vous voulez seulement concaténer des textes dans l’ordre de rencontre des éléments, utilisez le collecteur prédéfini Collectors.joining.

Exemples

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

Résultat

count=3, totalLength=9

Le tableau `long[]` contient le nombre de chaînes et la somme de leurs valeurs `String.length()`. Le `combiner` additionne les cases correspondantes et le `finisher` crée un record `Totals`. Pour ces données, un flux parallèle comme un flux séquentiel produit `count=3, totalLength=9`.

Leçons associées

  • Java · Leçon 45 · Intermédiaire · Version : 2

Sources