Collectors
Collectors 配合 stream 可以实现 MapReduce 操作，也可以单独完成流中元素的收集。
收集器接口和实现
/**
* 收集器接口
*/
public interface Collector<T, A, R> {
/**
* 创建并返回一个可变的结果容器
*/
Supplier<A> supplier();
/**
* 创建并返回一个将值归约到可变结果容器中的累加器
*/
BiConsumer<A, T> accumulator();
/**
* 创建并返回一个将两个结果容器进行合并的组合器，适用于并行计算
*/
BinaryOperator<A> combiner();
/**
* 创建并返回一个将结果容器转换为最终输出的完成器
*/
Function<A, R> finisher();
/**
* 此收集器所持有的 Collector.Characteristics 特征集
*/
Set<Characteristics> characteristics();
/**
* 用于优化归约操作的收集器特征值
*/
enum Characteristics {
/**
* 结果容器支持并发处理
*/
CONCURRENT,
/**
* 收集器处理元素时是无序的
*/
UNORDERED,
/**
* 结果容器就是最终返回的结果，不需要执行完成器操作
*/
IDENTITY_FINISH
}
}
/**
* Collector 接口的简单实现
*/
static class CollectorImpl<T, A, R> implements Collector<T, A, R> {
private final Supplier<A> supplier;
private final BiConsumer<A, T> accumulator;
private final BinaryOperator<A> combiner;
private final Function<A, R> finisher;
private final Set<Characteristics> characteristics;
CollectorImpl(Supplier<A> supplier,
BiConsumer<A, T> accumulator,
BinaryOperator<A> combiner,
Function<A,R> finisher,
Set<Characteristics> characteristics) {
this.supplier = supplier;
this.accumulator = accumulator;
this.combiner = combiner;
this.finisher = finisher;
this.characteristics = characteristics;
}
CollectorImpl(Supplier<A> supplier,
BiConsumer<A, T> accumulator,
BinaryOperator<A> combiner,
Set<Characteristics> characteristics) {
this(supplier, accumulator, combiner, castingIdentity(), characteristics);
}
@Override
public BiConsumer<A, T> accumulator() {
return accumulator;
}
@Override
public Supplier<A> supplier() {
return supplier;
}
@Override
public BinaryOperator<A> combiner() {
return combiner;
}
@Override
public Function<A, R> finisher() {
return finisher;
}
@Override
public Set<Characteristics> characteristics() {
return characteristics;
}
}
简单的结果收集
- toList()：将流中的元素收集到一个 ArrayList 中
/**
* 将流中的元素收集到一个 ArrayList 中
*/
public static <T>
Collector<T, ?, List<T>> toList() {
return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
(left, right) -> { left.addAll(right); return left; },
CH_ID);
}
ReferencePipeline#
@Override
@SuppressWarnings("unchecked")
public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) {
A container;
// 1）如果是并行收集 && 收集器的结果容器支持并发处理 && 元素是无序的
if (isParallel()
&& collector.characteristics().contains(Collector.Characteristics.CONCURRENT)
&& (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) {
// 通过共享的结果容器完成收集
container = collector.supplier().get();
final BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator();
forEach(u -> accumulator.accept(container, u));
}
// 2）收集过程是串行的 || 并行处理的收集器结果容器不支持并发
else {
// 执行收集过程，并返回结果容器
container = evaluate(ReduceOps.makeRef(collector));
}
/**
* 1）如果是 IDENTITY_FINISH，则直接返回结果容器
* 2）否则执行合并操作
*/
return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)
? (R) container
: collector.finisher().apply(container);
}
ReduceOps#
/**
* 创建一个用于归约引用对象的终端收集操作
*/
public static <T, I> TerminalOp<T, I>
makeRef(Collector<? super T, I, ?> collector) {
// 获取结果容器的生成器
final Supplier<I> supplier = Objects.requireNonNull(collector).supplier();
// 获取累加器的生成器
final BiConsumer<I, ? super T> accumulator = collector.accumulator();
// 获取合并器的生成器
final BinaryOperator<I> combiner = collector.combiner();
// 定义 ReducingSink
class ReducingSink extends Box<I>
implements AccumulatingSink<T, I, ReducingSink> {
@Override
public void begin(long size) {
// 生成结果容器并写入 state
state = supplier.get();
}
@Override
public void accept(T t) {
// 使用累加器进行归约
accumulator.accept(state, t);
}
@Override
public void combine(ReducingSink other) {
// 使用合并器进行两个结果容器的合并
state = combiner.apply(state, other.state);
}
}
return new ReduceOp<T, I, ReducingSink>(StreamShape.REFERENCE) {
@Override
public ReducingSink makeSink() {
return new ReducingSink();
}
@Override
public int getOpFlags() {
return collector.characteristics().contains(Collector.Characteristics.UNORDERED)
? StreamOpFlag.NOT_ORDERED
: 0;
}
};
}
/**
* 用于执行 reduce 操作的终端 sink
*/
private interface AccumulatingSink<T, R, K extends AccumulatingSink<T, R, K>>
extends TerminalSink<T, R> {
void combine(K other);
}
/**
* 用于保存单个结果值的容器
*/
private abstract static class Box<U> {
/**
* 结果值
*/
U state;
Box() {} // Avoid creation of special accessor
public U get() {
return state;
}
}
/**
* 一个终端归约操作，用于评估流水线中产生的每个元素，并将其发送到收集器中
*/
private abstract static class ReduceOp<T, R, S extends AccumulatingSink<T, R, S>>
implements TerminalOp<T, R> {
/**
* 输入元素类型
*/
private final StreamShape inputShape;
ReduceOp(StreamShape shape) {
inputShape = shape;
}
/**
* 创建 sink
*/
public abstract S makeSink();
@Override
public StreamShape inputShape() {
return inputShape;
}
/**
* 串行处理流水线中生成的元素
*/
@Override
public <P_IN> R evaluateSequential(PipelineHelper<T> helper,
Spliterator<P_IN> spliterator) {
return helper.wrapAndCopyInto(makeSink(), spliterator).get();
}
/**
* 并行处理流水线中生成的元素
*/
@Override
public <P_IN> R evaluateParallel(PipelineHelper<T> helper,
Spliterator<P_IN> spliterator) {
return new ReduceTask<>(this, helper, spliterator).invoke().get();
}
}
/**
* A {@code ForkJoinTask} for performing a parallel reduce operation.
*/
@SuppressWarnings("serial")
private static final class ReduceTask<P_IN, P_OUT, R,
S extends AccumulatingSink<P_OUT, R, S>>
extends AbstractTask<P_IN, P_OUT, S, ReduceTask<P_IN, P_OUT, R, S>> {
/**
* 终端归约操作
*/
private final ReduceOp<P_OUT, R, S> op;
ReduceTask(ReduceOp<P_OUT, R, S> op,
PipelineHelper<P_OUT> helper,
Spliterator<P_IN> spliterator) {
super(helper, spliterator);
this.op = op;
}
ReduceTask(ReduceTask<P_IN, P_OUT, R, S> parent,
Spliterator<P_IN> spliterator) {
super(parent, spliterator);
this.op = parent.op;
}
/**
* 创建一个子任务
*/
@Override
protected ReduceTask<P_IN, P_OUT, R, S> makeChild(Spliterator<P_IN> spliterator) {
return new ReduceTask<>(this, spliterator);
}
/**
* 执行此叶子任务的元素收集
*/
@Override
protected S doLeaf() {
return helper.wrapAndCopyInto(op.makeSink(), spliterator);
}
@Override
public void onCompletion(CountedCompleter<?> caller) {
// 如果不是叶子任务，则需要合并两个子节点的结果
if (!isLeaf()) {
// 读取左子节点的任务执行结果
S leftResult = leftChild.getLocalResult();
// 读取右子节点的任务执行结果，并使用合并器进行累加
leftResult.combine(rightChild.getLocalResult());
// 写入结果到当前任务中
setLocalResult(leftResult);
}
// GC spliterator, left and right child
super.onCompletion(caller);
}
}
- toCollection()：将流中的元素收集到一个 Collection 中
/**
* 将流中的元素收集到一个 Collection 中
*/
public static <T, C extends Collection<T>>
Collector<T, ?, C> toCollection(Supplier<C> collectionFactory) {
return new CollectorImpl<>(collectionFactory, Collection<T>::add,
(r1, r2) -> { r1.addAll(r2); return r1; },
CH_ID);
}
- toSet()：将流中的元素收集到一个 HashSet 中
/**
* 将流中的元素收集到一个 HashSet 中
*/
public static <T>
Collector<T, ?, Set<T>> toSet() {
return new CollectorImpl<>((Supplier<Set<T>>) HashSet::new, Set::add,
(left, right) -> {
// 根据结果容器的大小，优化合并过程
if (left.size() < right.size()) {
right.addAll(left); return right;
} else {
left.addAll(right); return left;
}
},
CH_UNORDERED_ID);
}
- toMap()：将流中的元素收集到一个 map 中，键不能重复、值不能为 null。如果键出现重复，则抛出 IllegalStateException 异常
/**
* 将流中的元素收集到一个 map 中，如果键出现重复，则抛出 IllegalStateException 异常。
*
* @param <T> 输入元素类型
* @param <K> 键元素类型
* @param <U> 值元素类型
* @param keyMapper 基于输入元素生成键
* @param valueMapper 基于输入元素生成值
*/
public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
return new CollectorImpl<>(HashMap::new,
uniqKeysMapAccumulator(keyMapper, valueMapper),
uniqKeysMapMerger(),
CH_ID);
}
private static <T, K, V>
BiConsumer<Map<K, V>, T> uniqKeysMapAccumulator(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends V> valueMapper) {
return (map, element) -> {
// 生成键
final K k = keyMapper.apply(element);
// 生成值，值不能为 null
final V v = Objects.requireNonNull(valueMapper.apply(element));
// 如果键已经存在，则抛出 IllegalStateException 异常
final V u = map.putIfAbsent(k, v);
if (u != null) {
throw duplicateKeyException(k, u, v);
}
};
}
/**
* 将两个 map 中的键值对进行合并【考虑计算 size 进行优化处理】。
* 键出现重复，则抛出 IllegalStateException 异常
*/
private static <K, V, M extends Map<K,V>>
BinaryOperator<M> uniqKeysMapMerger() {
return (m1, m2) -> {
for (final Map.Entry<K,V> e : m2.entrySet()) {
final K k = e.getKey();
final V v = Objects.requireNonNull(e.getValue());
final V u = m1.putIfAbsent(k, v);
if (u != null) {
throw duplicateKeyException(k, u, v);
}
}
return m1;
};
}
- toMap()：将流中的元素收集到一个 map 中，合并时执行 megre 操作【键冲突不会跑异常】
/**
* 将流中的元素收集到一个 map 中，合并时执行 megre 操作【键冲突不会跑异常】
*/
public static <T, K, U>
Collector<T, ?, Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction) {
return toMap(keyMapper, valueMapper, mergeFunction, HashMap::new);
}
public static <T, K, U, M extends Map<K, U>>
Collector<T, ?, M> toMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction,
Supplier<M> mapFactory) {
// 使用 merge 函数进行归约
final BiConsumer<M, T> accumulator
= (map, element) -> map.merge(keyMapper.apply(element),
valueMapper.apply(element), mergeFunction);
return new CollectorImpl<>(mapFactory, accumulator, mapMerger(mergeFunction), CH_ID);
}
/**
* 将右侧的 map 合并进左侧的 map，键冲突时使用 merge 函数进行处理
*/
private static <K, V, M extends Map<K,V>>
BinaryOperator<M> mapMerger(BinaryOperator<V> mergeFunction) {
return (m1, m2) -> {
for (final Map.Entry<K,V> e : m2.entrySet()) {
m1.merge(e.getKey(), e.getValue(), mergeFunction);
}
return m1;
};
}
- toConcurrentMap：将流中的元素收集到一个 ConcurrentHashMap 中，键和值都不能为 null，键不能重复。
/**
* 将流中的元素收集到一个 ConcurrentHashMap 中
*/
public static <T, K, U>
Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
return new CollectorImpl<>(ConcurrentHashMap::new,
uniqKeysMapAccumulator(keyMapper, valueMapper),
uniqKeysMapMerger(),
CH_CONCURRENT_ID);
}
- toUnmodifiableList()：将流中的元素收集到一个不可变的 List 中
/**
* 将流中的元素收集到一个不可变的 List 中
* @since 10
*/
@SuppressWarnings("unchecked")
public static <T>
Collector<T, ?, List<T>> toUnmodifiableList() {
return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
(left, right) -> { left.addAll(right); return left; },
list -> (List<T>)List.of(list.toArray()),
CH_NOID);
}
- toUnmodifiableSet()：将流中的元素收集到一个不可变的 set 中
/**
* 将流中的元素收集到一个不可变的 set 中
* @since 10
*/
@SuppressWarnings("unchecked")
public static <T>
Collector<T, ?, Set<T>> toUnmodifiableSet() {
return new CollectorImpl<>((Supplier<Set<T>>) HashSet::new, Set::add,
(left, right) -> {
if (left.size() < right.size()) {
right.addAll(left); return right;
} else {
left.addAll(right); return left;
}
},
set -> (Set<T>)Set.of(set.toArray()),
CH_UNORDERED_NOID);
}
- toUnmodifiableMap()：将流中的元素收集到一个不可变的 Map 中
/**
* 将流中的元素收集到一个不可变的 Map 中
* @since 10
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public static <T, K, U>
Collector<T, ?, Map<K,U>> toUnmodifiableMap(Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper) {
Objects.requireNonNull(keyMapper, "keyMapper");
Objects.requireNonNull(valueMapper, "valueMapper");
return collectingAndThen(
toMap(keyMapper, valueMapper),
map -> (Map<K,U>)Map.ofEntries(map.entrySet().toArray(new Map.Entry[0])));
}
自定义归约
- reducing()：使用 BinaryOperator 对流中的元素进行归约，返回一个 Optional 对象，未指定初始值。
/**
* 使用 BinaryOperator 对流中的元素进行归约，返回一个 Optional 对象
*/
public static <T> Collector<T, ?, Optional<T>>
reducing(BinaryOperator<T> op) {
class OptionalBox implements Consumer<T> {
/**
* 结果值
*/
T value = null;
/**
* 是否已经有结果值
*/
boolean present = false;
@Override
public void accept(T t) {
// 1）如果已经有结果值，则执行归约
if (present) {
value = op.apply(value, t);
}
// 2）第一个元素，则直接写入结果值中
else {
value = t;
present = true;
}
}
}
return new CollectorImpl<>(
OptionalBox::new, OptionalBox::accept,
(a, b) -> { if (b.present) {
a.accept(b.value);
} return a; },
a -> Optional.ofNullable(a.value), CH_NOID);
}
- 使用 BinaryOperator 对流中的元素进行归约，指定初始值为 identity。
/**
*/
public static <T> Collector<T, ?, T>
reducing(T identity, BinaryOperator<T> op) {
return new CollectorImpl<>(
// 初始值生成器
boxSupplier(identity),
// 通过数组来暂存值
(a, t) -> { a[0] = op.apply(a[0], t); },
(a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
a -> a[0],
CH_NOID);
}
@SuppressWarnings("unchecked")
private static <T> Supplier<T[]> boxSupplier(T identity) {
return () -> (T[]) new Object[] { identity };
}
- 使用 BinaryOperator 对流中的元素进行归约，归约前先使用 mapper 进行映射处理，指定初始值为 identity。
/**
*/
public static <T, U>
Collector<T, ?, U> reducing(U identity,
Function<? super T, ? extends U> mapper,
BinaryOperator<U> op) {
return new CollectorImpl<>(
boxSupplier(identity),
// 先使用 mapper 进行映射，然后再归约
(a, t) -> { a[0] = op.apply(a[0], mapper.apply(t)); },
(a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
a -> a[0], CH_NOID);
}
统计
- averagingInt()：先将流中的元素转换为 int 值，然后统计平均值
/**
* 先将流中的元素转换为 int 值，然后统计平均值
*/
public static <T> Collector<T, ?, Double>
averagingInt(ToIntFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new long[2],
// 第一个 slot 记录总和，第二个 slot 记录总个数
(a, t) -> { a[0] += mapper.applyAsInt(t); a[1]++; },
(a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
a -> a[1] == 0 ? 0.0d : (double) a[0] / a[1], CH_NOID);
}
- averagingLong()：先将流中的元素转换为 long 值，然后统计平均值
/**
* 先将流中的元素转换为 long 值，然后统计平均值
*/
public static <T> Collector<T, ?, Double>
averagingLong(ToLongFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new long[2],
// 第一个 slot 记录总和，第二个 slot 记录总个数
(a, t) -> { a[0] += mapper.applyAsLong(t); a[1]++; },
(a, b) -> { a[0] += b[0]; a[1] += b[1]; return a; },
a -> a[1] == 0 ? 0.0d : (double) a[0] / a[1], CH_NOID);
}
- averagingDouble()：先将流中的元素转换为 double 值，然后统计平均值
/**
* 先将流中的元素转换为 double 值，然后统计平均值
*/
public static <T> Collector<T, ?, Double>
averagingDouble(ToDoubleFunction<? super T> mapper) {
/*
* In the arrays allocated for the collect operation, index 0
* holds the high-order bits of the running sum, index 1 holds
* the low-order bits of the sum computed via compensated
* summation, and index 2 holds the number of values seen.
*/
return new CollectorImpl<>(
() -> new double[4],
(a, t) -> { final double val = mapper.applyAsDouble(t); sumWithCompensation(a, val); a[2]++; a[3]+= val;},
(a, b) -> { sumWithCompensation(a, b[0]); sumWithCompensation(a, b[1]); a[2] += b[2]; a[3] += b[3]; return a; },
a -> a[2] == 0 ? 0.0d : computeFinalSum(a) / a[2],
CH_NOID);
}
- summingInt()：先将流中的元素转换为 int 值，然后统计总和
/**
* 先将流中的元素转换为 int 值，然后统计总和
*/
public static <T> Collector<T, ?, Integer>
summingInt(ToIntFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new int[1],
(a, t) -> { a[0] += mapper.applyAsInt(t); },
(a, b) -> { a[0] += b[0]; return a; },
a -> a[0], CH_NOID);
}
- summingLong()：先将流中的元素转换为 long 值，然后统计总和
/**
* 先将流中的元素转换为 long 值，然后统计总和
*/
public static <T> Collector<T, ?, Long>
summingLong(ToLongFunction<? super T> mapper) {
return new CollectorImpl<>(
() -> new long[1],
(a, t) -> { a[0] += mapper.applyAsLong(t); },
(a, b) -> { a[0] += b[0]; return a; },
a -> a[0], CH_NOID);
}
- summingDouble()：先将流中的元素转换为 double 值，然后统计总和
/**
* 先将流中的元素转换为 double 值，然后统计总和
*/
public static <T> Collector<T, ?, Double>
summingDouble(ToDoubleFunction<? super T> mapper) {
/*
* In the arrays allocated for the collect operation, index 0
* holds the high-order bits of the running sum, index 1 holds
* the low-order bits of the sum computed via compensated
* summation, and index 2 holds the simple sum used to compute
* the proper result if the stream contains infinite values of
* the same sign.
*/
return new CollectorImpl<>(
() -> new double[3],
(a, t) -> { final double val = mapper.applyAsDouble(t);
sumWithCompensation(a, val);
a[2] += val;},
(a, b) -> { sumWithCompensation(a, b[0]);
a[2] += b[2];
return sumWithCompensation(a, b[1]); },
a -> computeFinalSum(a),
CH_NOID);
}
- summarizingInt()：先将流中的元素转换为 int 值，然后统计到 IntSummaryStatistics【合并了 count、sum、min、max、avg】 中。
/**
* 先将流中的元素转换为 int 值，然后统计到 IntSummaryStatistics【合并了 count、sum、min、max、avg】 中。
*/
public static <T>
Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper) {
return new CollectorImpl<>(
IntSummaryStatistics::new,
(r, t) -> r.accept(mapper.applyAsInt(t)),
(l, r) -> { l.combine(r); return l; }, CH_ID);
}
- summarizingLong()：先将流中的元素转换为 long 值，然后统计到 LongSummaryStatistics【合并了 count、sum、min、max、avg】 中。
/**
* 先将流中的元素转换为 long 值，然后统计到 LongSummaryStatistics【合并了 count、sum、min、max、avg】 中。
*/
public static <T>
Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper) {
return new CollectorImpl<>(
LongSummaryStatistics::new,
(r, t) -> r.accept(mapper.applyAsLong(t)),
(l, r) -> { l.combine(r); return l; }, CH_ID);
}
- summarizingDouble()：先将流中的元素转换为 double 值，然后统计到 DoubleSummaryStatistics【合并了 count、sum、min、max、avg】 中。
/**
* 先将流中的元素转换为 double 值，然后统计到 DoubleSummaryStatistics【合并了 count、sum、min、max、avg】 中。
*/
public static <T>
Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper) {
return new CollectorImpl<>(
DoubleSummaryStatistics::new,
(r, t) -> r.accept(mapper.applyAsDouble(t)),
(l, r) -> { l.combine(r); return l; }, CH_ID);
}
/**
* 统计流中的总元素数
*/
public static <T> Collector<T, ?, Long>
counting() {
return summingLong(e -> 1L);
}
- minBy()：读取流中的最小值
```java
/**
* 读取流中的最小值
*/
public static <T> Collector<T, ?, Optional<T>>
minBy(Comparator<? super T> comparator) {
return reducing(BinaryOperator.minBy(comparator));
}
/**
* 读取流中的最大值
*/
public static <T> Collector<T, ?, Optional<T>>
maxBy(Comparator<? super T> comparator) {
return reducing(BinaryOperator.maxBy(comparator));
}
分组
/**
* 使用指定的分类器 classifier 将流中的元素进行分组，同一个组中的元素被收集到一个 ArrayList 中。
*/
public static <T, K> Collector<T, ?, Map<K, List<T>>>
groupingBy(Function<? super T, ? extends K> classifier) {
return groupingBy(classifier, toList());
}
/**
* 使用指定的分类器 classifier 将流中的元素进行分组，同一个组中的元素被收集到一个 downstream 收集器中。
*/
public static <T, K, A, D>
Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
Collector<? super T, A, D> downstream) {
return groupingBy(classifier, HashMap::new, downstream);
}
/**
* 使用指定的分类器 classifier 将流中的元素进行分组，同一个组中的元素被收集到一个 downstream 收集器中。
*/
public static <T, K, D, A, M extends Map<K, D>>
Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T, A, D> downstream) {
// 同一组元素的结果容器
final Supplier<A> downstreamSupplier = downstream.supplier();
// 同一组元素的累加器
final BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
// 分组累加器
final BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {
// 计算分组键
final K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
// 读取分组容器
final A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());
// 执行归约
downstreamAccumulator.accept(container, t);
};
// 并行分组的合并器
final BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());
// 结果容器的生成器
final Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;
// 1）无序合并处理
if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
}
// 2）执行合并处理
else {
@SuppressWarnings("unchecked")
final
Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
final Function<Map<K, A>, M> finisher = intermediate -> {
// 对所有的分组执行最后的映射
intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
@SuppressWarnings("unchecked")
final
M castResult = (M) intermediate;
return castResult;
};
return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
}
}
- groupingByConcurrent【并行分组】
/**
* 【并行分组】使用指定的分类器 classifier 将流中的元素进行分组，同一个组中的元素被收集到一个 ArrayList 中。
*/
public static <T, K>
Collector<T, ?, ConcurrentMap<K, List<T>>>
groupingByConcurrent(Function<? super T, ? extends K> classifier) {
return groupingByConcurrent(classifier, ConcurrentHashMap::new, toList());
}
/**
* 【并行分组】使用指定的分类器 classifier 将流中的元素进行分组，同一个组中的元素被收集到一个 downstream 收集器中。
*/
public static <T, K, A, D>
Collector<T, ?, ConcurrentMap<K, D>> groupingByConcurrent(Function<? super T, ? extends K> classifier,
Collector<? super T, A, D> downstream) {
return groupingByConcurrent(classifier, ConcurrentHashMap::new, downstream);
}
/**
* 【并行分组】使用指定的分类器 classifier 将流中的元素进行分组，同一个组中的元素被收集到一个 downstream 收集器中。
*/
public static <T, K, A, D, M extends ConcurrentMap<K, D>>
Collector<T, ?, M> groupingByConcurrent(Function<? super T, ? extends K> classifier,
Supplier<M> mapFactory,
Collector<? super T, A, D> downstream) {
final Supplier<A> downstreamSupplier = downstream.supplier();
final BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
final BinaryOperator<ConcurrentMap<K, A>> merger = Collectors.<K, A, ConcurrentMap<K, A>>mapMerger(downstream.combiner());
@SuppressWarnings("unchecked")
final
Supplier<ConcurrentMap<K, A>> mangledFactory = (Supplier<ConcurrentMap<K, A>>) mapFactory;
BiConsumer<ConcurrentMap<K, A>, T> accumulator;
// 同一个分组的结果容器是线程安全的
if (downstream.characteristics().contains(Collector.Characteristics.CONCURRENT)) {
accumulator = (m, t) -> {
final K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
final A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
downstreamAccumulator.accept(resultContainer, t);
};
}
// 同一个分组的结果容器是不是线程安全的，则使用 synchronized 实现同步
else {
accumulator = (m, t) -> {
final K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
final A resultContainer = m.computeIfAbsent(key, k -> downstreamSupplier.get());
synchronized (resultContainer) {
downstreamAccumulator.accept(resultContainer, t);
}
};
}
if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_CONCURRENT_ID);
}
else {
@SuppressWarnings("unchecked")
final
Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
final Function<ConcurrentMap<K, A>, M> finisher = intermediate -> {
intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
@SuppressWarnings("unchecked")
final
M castResult = (M) intermediate;
return castResult;
};
return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_CONCURRENT_NOID);
}
}
/**
* 使用指定的断言 predicate 对流中的元素进行二分，
* 断言结果为 true 的所有元素同一个组，断言结果为 false 的所有元素同一个组，
* 同一个组中的元素收集到一个 ArrayList 中。
*/
public static <T>
Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(Predicate<? super T> predicate) {
return partitioningBy(predicate, toList());
}
/**
* 使用指定的断言 predicate 对流中的元素进行二分，
* 断言结果为 true 的所有元素同一个组，断言结果为 false 的所有元素同一个组，
* 使用指定的收集器来收集同一个组中的元素。
*/
public static <T, D, A>
Collector<T, ?, Map<Boolean, D>> partitioningBy(Predicate<? super T> predicate,
Collector<? super T, A, D> downstream) {
// 同一组的累加器
final BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
// 流的累加器
final BiConsumer<Partition<A>, T> accumulator = (result, t) ->
downstreamAccumulator.accept(predicate.test(t) ? result.forTrue : result.forFalse, t);
// 同一组的合并器
final BinaryOperator<A> op = downstream.combiner();
// 流的合并器
final BinaryOperator<Partition<A>> merger = (left, right) ->
new Partition<>(op.apply(left.forTrue, right.forTrue),
op.apply(left.forFalse, right.forFalse));
// 结果容器生成器
final Supplier<Partition<A>> supplier = () ->
new Partition<>(downstream.supplier().get(),
downstream.supplier().get());
if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
return new CollectorImpl<>(supplier, accumulator, merger, CH_ID);
}
else {
final Function<Partition<A>, Map<Boolean, D>> finisher = par ->
new Partition<>(downstream.finisher().apply(par.forTrue),
downstream.finisher().apply(par.forFalse));
return new CollectorImpl<>(supplier, accumulator, merger, finisher, CH_NOID);
}
}
其他
- filtering()：先对流中的元素执行过滤，满足断言的再执行收集。
/**
* 先对流中的元素执行过滤，满足断言的再执行收集。
* @since 9
*/
public static <T, A, R>
Collector<T, ?, R> filtering(Predicate<? super T> predicate,
Collector<? super T, A, R> downstream) {
final BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
return new CollectorImpl<>(downstream.supplier(),
(r, t) -> {
if (predicate.test(t)) {
downstreamAccumulator.accept(r, t);
}
},
downstream.combiner(), downstream.finisher(),
downstream.characteristics());
}
- mapping()：先对流中的元素执行映射，然后再执行收集。
/**
* 先对流中的元素执行映射，然后再执行收集。
*/
public static <T, U, A, R>
Collector<T, ?, R> mapping(Function<? super T, ? extends U> mapper,
Collector<? super U, A, R> downstream) {
final BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();
return new CollectorImpl<>(downstream.supplier(),
(r, t) -> downstreamAccumulator.accept(r, mapper.apply(t)),
downstream.combiner(), downstream.finisher(),
downstream.characteristics());
}
- flatMapping()：通过流中的每一个元素生成一个子流，然后再对子流中的元素执行收集
/**
* 通过流中的每一个元素生成一个子流，然后再对子流中的元素执行收集
* @since 9
*/
public static <T, U, A, R>
Collector<T, ?, R> flatMapping(Function<? super T, ? extends Stream<? extends U>> mapper,
Collector<? super U, A, R> downstream) {
final BiConsumer<A, ? super U> downstreamAccumulator = downstream.accumulator();
return new CollectorImpl<>(downstream.supplier(),
(r, t) -> {
try (Stream<? extends U> result = mapper.apply(t)) {
if (result != null) {
result.sequential().forEach(u -> downstreamAccumulator.accept(r, u));
}
}
},
downstream.combiner(), downstream.finisher(),
downstream.characteristics());
}
/**
* 对元素类型为 String 的流中的每一个元素执行拼接
*/
public static Collector<CharSequence, ?, String> joining() {
return new CollectorImpl<>(
StringBuilder::new, StringBuilder::append,
(r1, r2) -> { r1.append(r2); return r1; },
StringBuilder::toString, CH_NOID);
}
/**
* 对元素类型为 String 的流中的每一个元素执行拼接，指定分割符为 delimiter
*/
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter) {
return joining(delimiter, "", "");
}
/**
* 对元素类型为 String 的流中的每一个元素执行拼接，指定分割符为 delimiter，结果前缀为 prefix，结果后缀为 suffix
*/
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) {
return new CollectorImpl<>(
() -> new StringJoiner(delimiter, prefix, suffix),
StringJoiner::add, StringJoiner::merge,
StringJoiner::toString, CH_NOID);
}