Java Academy · Leçon

Créer un collecteur personnalisé

Implémentez l’interface Collector pour créer une agrégation réutilisable adaptée à un cas d’utilisation particulier.

Créer un collecteur personnalisé est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Pourquoi créer un collecteur personnalisé ?

Lorsque les collecteurs intégrés ne conviennent pas à votre domaine, implémentez l’interface Collector<T, A, R> afin de créer une logique d’agrégation réutilisable et composable. T = entrée, A = accumulateur mutable, R = résultat.

L’interface du collecteur

Un collecteur possède cinq composants :

supplier() — crée l’accumulateur initial
accumulator() — incorpore un élément dans l’accumulateur
combiner() — fusionne deux accumulateurs, pour les streams parallèles
finisher() — transforme l’accumulateur en résultat final
characteristics() — fournit des indications d’optimisation

Fabrique Collector.of()

La manière la plus simple de créer un collecteur personnalisé consiste à utiliser Collector.of() sans implémenter directement l’interface :

import java.util.stream.*;

// Collector that builds a comma-separated String
Collector<String, StringBuilder, String> csvCollector = Collector.of(
    StringBuilder::new,                     // supplier
    (sb, s) -> {
        if (sb.length() > 0) sb.append(',');
        sb.append(s);
    },                                       // accumulator
    (a, b) -> {
        if (a.length() > 0 && b.length() > 0) a.append(',');
        a.append(b); return a;
    },                                       // combiner
    StringBuilder::toString                  // finisher
);

String csv = Stream.of("Alice","Bob","Carol").collect(csvCollector);
System.out.println(csv); // Alice,Bob,Carol

Collecteur personnalisé : TopN

Créez un collecteur qui ne conserve que les N meilleurs éléments selon un comparateur :

import java.util.*;
import java.util.stream.*;

static <T> Collector<T, ?, List<T>> topN(int n, Comparator<T> comp) {
    return Collector.of(
        () -> new ArrayList<T>(),
        (list, e) -> {
            list.add(e);
            list.sort(comp.reversed());
            if (list.size() > n) list.remove(list.size() - 1);
        },
        (a, b) -> {
            a.addAll(b);
            a.sort(comp.reversed());
            while (a.size() > n) a.remove(a.size() - 1);
            return a;
        },
        Collector.Characteristics.UNORDERED
    );
}

Utiliser le collecteur TopN

Appliquez le collecteur personnalisé TopN à un stream :

List<Integer> top3 = Stream.of(5,2,9,1,7,3,8)
    .collect(topN(3, Comparator.naturalOrder()));
System.out.println(top3); // [9, 8, 7]

Indicateurs de caractéristiques

Trois caractéristiques facultatives permettent d’optimiser le stream :

IDENTITY_FINISH — la fonction de finalisation est l’identité ; ignorez-la
UNORDERED — l’ordre du résultat n’a pas d’importance
CONCURRENT — l’accumulateur peut être appelé simultanément

Définir le mauvais indicateur, par exemple CONCURRENT sans garantir la sécurité d’exécution concurrente, provoque des erreurs.

Collecteur personnalisé : moyenne progressive

Maintenez une moyenne progressive sans effectuer de second passage :

record RunningAvg(long count, double sum) {
    RunningAvg add(double v) { return new RunningAvg(count+1, sum+v); }
    RunningAvg merge(RunningAvg o) { return new RunningAvg(count+o.count, sum+o.sum); }
    double avg() { return count == 0 ? 0 : sum / count; }
}

Collector<Double, RunningAvg[], Double> avgCollector = Collector.of(
    () -> new RunningAvg[]{new RunningAvg(0, 0)},
    (a, v) -> a[0] = a[0].add(v),
    (a, b) -> { a[0] = a[0].merge(b[0]); return a; },
    a -> a[0].avg()
);

double avg = Stream.of(10.0, 20.0, 30.0).collect(avgCollector);
System.out.println(avg); // 20.0

Implémenter directement l’interface du collecteur

Pour exercer davantage de contrôle, implémentez Collector<T,A,R> sous forme de classe :

import java.util.function.*;
import java.util.stream.*;

class StringJoiningCollector implements Collector<String, List<String>, String> {
    private final String delimiter;
    StringJoiningCollector(String delimiter) { this.delimiter = delimiter; }
    public Supplier<List<String>> supplier() { return ArrayList::new; }
    public BiConsumer<List<String>, String> accumulator() { return List::add; }
    public BinaryOperator<List<String>> combiner() {
        return (a,b) -> { a.addAll(b); return a; };
    }
    public Function<List<String>, String> finisher() {
        return list -> String.join(delimiter, list);
    }
    public Set<Characteristics> characteristics() { return Set.of(); }
}

Comparaison entre collecteurs personnalisés et intégrés

Avant d’écrire un collecteur personnalisé, vérifiez si la composition de collecteurs intégrés permet d’obtenir le même résultat : ils sont déjà testés et optimisés :

// Instead of custom, compose:
Map<String, IntSummaryStatistics> stats = orders.stream().collect(
    Collectors.groupingBy(Order::status,
        Collectors.summarizingInt(Order::amount))
);
// This replaces many custom collector implementations

Sécurité d’exécution concurrente des collecteurs personnalisés

Si la caractéristique CONCURRENT est définie, l’accumulateur est appelé simultanément par plusieurs threads. Il doit alors être sûr en contexte concurrent, par exemple en utilisant ConcurrentHashMap ou AtomicLong. Sans CONCURRENT, le combiner gère le parallélisme de manière sûre.

Cas concret : collecteur d’histogramme

Répartissez les valeurs numériques dans des intervalles pour créer une carte d’histogramme :

Collector<Integer, Map<Integer, Long>, Map<Integer, Long>> histogram =
    Collector.of(
        LinkedHashMap::new,
        (map, val) -> map.merge(val / 10 * 10, 1L, Long::sum),
        (a, b) -> { b.forEach((k,v) -> a.merge(k,v,Long::sum)); return a; },
        Collector.Characteristics.IDENTITY_FINISH
    );

Map<Integer,Long> hist = Stream.of(5,15,25,12,8,22,18,3)
    .collect(histogram);
hist.forEach((bucket, cnt) -> System.out.println(bucket+"-"+(bucket+9)+": "+cnt));

Vérification rapide

Quel indicateur de caractéristiques du collecteur indique que la fonction de finalisation est la transformation identité et peut être ignorée ?

Récapitulatif : collecteurs personnalisés

Points essentiels :

Collecteur<T,A,R> : T = entrée, A = accumulateur, R = résultat
Utilisez Collector.of() pour une implémentation rapide sans créer de classe
supplier/accumulator/combiner/finisher/characteristics sont les cinq composants
La finalisation par identité, l’absence d’ordre et l’exécution concurrente sont des indicateurs d’optimisation
Privilégiez la composition de collecteurs intégrés ; ne créez un collecteur personnalisé qu’en cas de besoin

Questions Fréquemment Posées

La leçon « Créer un collecteur personnalisé » est-elle gratuite ?

Oui — le texte complet de « Créer un collecteur personnalisé » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Créer un collecteur personnalisé » ?

Implémentez l’interface Collector pour créer une agrégation réutilisable adaptée à un cas d’utilisation particulier. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Créer un collecteur personnalisé » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy