CKTIS / Java
Collector.of: crea un colector personalizado con cuatro funciones
Define un colector de flujos que cree un estado de trabajo, incorpore elementos, combine resultados parciales y produzca el valor final.
Versión: Java SE 21
Sintaxis
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 es un método de fábrica estático de la interfaz java.util.stream.Collector. Crea un colector que se pasa a la operación terminal Stream.collect(collector). En Collector<T, A, R>, T es el tipo de los elementos de entrada, A el del estado intermedio mutable y R el del resultado final.
En la sobrecarga de cuatro funciones, supplier crea un contenedor A nuevo y vacío en cada llamada; accumulator lo actualiza con un elemento T y no devuelve nada; combiner fusiona dos resultados parciales y devuelve el estado combinado A; y finisher transforma el estado final A en R. Después de las funciones se pueden indicar opciones de tipo Collector.Characteristics. Ambas sobrecargas lanzan NullPointerException si un argumento es null.
Una reducción paralela puede llenar contenedores separados y fusionarlos después. Reducir la entrada con y sin dividirla debe dar resultados equivalentes. Para un colector con la característica UNORDERED, dos resultados pueden ser equivalentes aunque difieran solo en el orden. Combinar un resultado parcial con un contenedor vacío como segundo argumento debe dar un resultado equivalente. No devuelvas un contenedor mutable compartido desde supplier ni declares CONCURRENT a menos que accumulator pueda actualizar el mismo contenedor de forma segura desde varios hilos a la vez.
La sobrecarga de tres funciones no recibe finisher: devuelve Collector<T, R, R> y activa automáticamente IDENTITY_FINISH. Es una característica, no un método llamado Collector.identityFinish, y permite omitir finisher durante la reducción. No la actives si finisher realiza una transformación necesaria. Si solo quieres concatenar texto en el orden en que aparecen los elementos, usa el colector predefinido Collectors.joining.
Ejemplos
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());
}
}Resultado
count=3, totalLength=9
El array `long[]` guarda el número de cadenas y la suma de sus valores de `String.length()`. `combiner` suma las posiciones correspondientes y `finisher` crea un registro `Totals`. Tanto un flujo paralelo como uno secuencial producen `count=3, totalLength=9` con estos datos.
Lecciones relacionadas
- Java · Lección 45 · Intermedio · Versión: 2