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

CKTIS / Java

Collector — réduction mutable personnalisée de flux

Collector<T, A, R> décrit l’accumulation des éléments d’un flux dans un état mutable, puis leur transformation en résultat. Découvrez les fonctions du collecteur, les exigences du traitement parallèle et la signification de ses caractéristiques dans Java SE 21.

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

Syntaxe

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

Collector<T, A, R> décrit une réduction mutable utilisée par Stream.collect : T est l’élément, A l’état d’accumulation et R le résultat. Ne confondez pas l’interface Collector avec la classe Collectors, qui fournit des collecteurs prêts à l’emploi. Périmètre : Java SE 21 ; l’environnement d’exécution du dépôt et celui de production ne sont pas attestés.

Collector.supplier() renvoie une fonction qui crée un nouveau conteneur mutable ; Collector.accumulator() renvoie une fonction qui incorpore un élément ; Collector.combiner() renvoie une fonction qui fusionne des états partiels ; Collector.finisher() renvoie une fonction qui convertit A en R. Collector.of construit un collecteur à partir de ces fonctions. La surcharge sans finisseur explicite a A = R et déclare automatiquement IDENTITY_FINISH.

Collector.characteristics() renvoie un ensemble immuable de propriétés déclarées. Collector.Characteristics.CONCURRENT autorise des appels simultanés de l’accumulateur sur le même conteneur. Collector.Characteristics.UNORDERED signifie qu’il n’y a pas d’engagement à préserver l’ordre de rencontre. L’accumulation concurrente partagée exige CONCURRENT et soit UNORDERED, soit un flux non ordonné. Collector.Characteristics.IDENTITY_FINISH permet d’ignorer le finisseur : celui-ci doit être une transformation identité, et la conversion de A en R par transtypage doit réussir. Les indicateurs décrivent des garanties ; ils ne fournissent pas de synchronisation.

La combinaison doit être associative et cohérente avec l’accumulation ; la fusion d’un état vide ne doit pas modifier le résultat. Un collecteur sans CONCURRENT peut s’exécuter en parallèle : la bibliothèque isole les états partiels, puis les combine. Ne partagez pas un même conteneur mutable entre les appels du fournisseur.

L’exemple préserve l’ordre et utilise StringBuilder comme A et String comme R. Il ne déclare aucune caractéristique : StringBuilder ne prend pas en charge l’accumulation concurrente partagée, et le finisseur change le type. Les deux modes de collecte sont censés afficher ABC.

Exemples

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

Résultat

ABC
ABC
true

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources