CKTIS / Java
Collector.of: einen eigenen Collector mit vier Funktionen erstellen
Definiere einen Stream-Collector, der einen Arbeitszustand anlegt, Elemente einarbeitet, Teilergebnisse zusammenführt und den Endwert erzeugt.
Version: 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 ist eine statische Fabrikmethode der Schnittstelle java.util.stream.Collector. Sie erzeugt einen Collector für die terminale Operation Stream.collect(collector). In Collector<T, A, R> steht T für den Eingabeelementtyp, A für den Typ des veränderlichen Zwischenzustands und R für den Typ des Endergebnisses.
Bei der Überladung mit vier Funktionen erzeugt der supplier bei jedem Aufruf einen neuen, leeren Container vom Typ A. Der accumulator arbeitet ein Element vom Typ T ein und gibt nichts zurück. Der combiner führt zwei Teilergebnisse zusammen und gibt den kombinierten Zustand A zurück. Der finisher wandelt den abschließenden Zustand A in R um. Auf die Funktionen können optionale Flags vom Typ Collector.Characteristics folgen. Beide Überladungen werfen NullPointerException, wenn ein Argument null ist.
Bei einer parallelen Reduktion können getrennte Container gefüllt und anschließend zusammengeführt werden. Die Reduktion mit und ohne Aufteilung der Eingabe muss gleichwertige Ergebnisse liefern. Bei einem Collector mit UNORDERED können Ergebnisse auch dann gleichwertig sein, wenn sie sich nur in der Reihenfolge unterscheiden. Wird ein leeres Gefäß als rechter Operand mit einem Teilergebnis kombiniert, muss das Ergebnis gleichwertig bleiben. Gib im supplier keinen gemeinsam genutzten veränderlichen Container zurück. Setze CONCURRENT nur, wenn der accumulator denselben Container aus mehreren Threads gleichzeitig sicher ändern kann.
Die Überladung mit drei Funktionen nimmt keinen finisher entgegen: Sie liefert Collector<T, R, R> und setzt automatisch IDENTITY_FINISH. Das ist ein Flag und keine Methode namens Collector.identityFinish; damit darf die Reduktion den Finisher überspringen. Setze das Flag nicht, wenn der finisher eine notwendige Umwandlung durchführt. Wenn du lediglich Texte in der Reihenfolge ihres Auftretens verketten möchtest, verwende den vordefinierten Collector Collectors.joining.
Beispiele
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());
}
}Ergebnis
count=3, totalLength=9
Das Array `long[]` enthält die Anzahl der Zeichenketten und die Summe ihrer `String.length()`-Werte. Der `combiner` addiert die jeweils entsprechenden Einträge, und der `finisher` erzeugt einen Record vom Typ `Totals`. Für diese Eingabe liefern parallele und sequenzielle Streams `count=3, totalLength=9`.
Zugehörige Lektionen
- Java · Lektion 45 · Mittlere Stufe · Version: 2