Collector

public interface Collector

将输入元素累加到可变结果容器中的一个mutable reduction operation ，可选地在处理完所有输入元素后将累加结果转换为最终表示形式。 缩减操作可以按顺序执行也可以并行执行。

可变减少操作的例子包括：将元素累加到Collection ; 使用StringBuilder连接字符串; 计算关于总和，最小值，最大值或平均值等元素的摘要信息; 计算“数据透视表”摘要，例如“卖方最大价值交易”等。类Collectors提供了许多常见的可变缩减的实现。

Collector由四个函数指定，这四个函数一起工作以将条目累加到可变结果容器中，并且可以对结果进行可选的最终变换。 他们是：

• creation of a new result container (supplier())
• incorporating a new data element into a result container (accumulator())
• combining two result containers into one (combiner())
• performing an optional final transform on the container (finisher())

收集器还具有一系列特性，例如 CONCURRENT ，它们提供了一些可用于缩减实施以提供更好性能的提示。

使用收集器连续执行缩减将使用供应商函数创建单个结果容器，并为每个输入元素调用一次累加器函数。 并行实现将对输入进行分区，为每个分区创建一个结果容器，将每个分区的内容累积到该分区的子结果中，然后使用合并器函数将子结果合并为合并结果。

为了确保顺序和并行执行产生等效的结果，集电极函数必须满足的 标识和一个 associativity个约束。

身份约束表示，对于任何部分累积结果，将其与空结果容器组合必须产生等效结果。 也就是说，对于部分累加结果a ，这是任何一系列累加器和组合器调用的结果， a必须等于combiner.apply(a, supplier.get()) 。

关联约束表示分割计算必须产生一个等效的结果。 也就是说，对于任何输入元素t1和t2 ，下面的计算中的结果r1和r2必须是等效的：

A a1 = supplier.get();
     accumulator.accept(a1, t1);
     accumulator.accept(a1, t2);
     R r1 = finisher.apply(a1);  // result without splitting

     A a2 = supplier.get();
     accumulator.accept(a2, t1);
     A a3 = supplier.get();
     accumulator.accept(a3, t2);
     R r2 = finisher.apply(combiner.apply(a2, a3));  // result with splitting
  

对于不具备收藏UNORDERED特征，二累加结果a1和a2是等价的，如果finisher.apply(a1).equals(finisher.apply(a2)) 。 对于无序的收藏家来说，放松等同是为了允许与秩序差异相关的不平等。 （例如，将元素累积到List的无序收集器会考虑两个相同的元素，如果它们包含相同的元素，则会忽略顺序。）

基于 Collector实施简化的 Collector （例如 collect(Collector) ）必须遵守以下约束：

• The first argument passed to the accumulator function, both arguments passed to the combiner function, and the argument passed to the finisher function must be the result of a previous invocation of the result supplier, accumulator, or combiner functions.
• The implementation should not do anything with the result of any of the result supplier, accumulator, or combiner functions other than to pass them again to the accumulator, combiner, or finisher functions, or return them to the caller of the reduction operation.
• If a result is passed to the combiner or finisher function, and the same object is not returned from that function, it is never used again.
• Once a result is passed to the combiner or finisher function, it is never passed to the accumulator function again.
• For non-concurrent collectors, any result returned from the result supplier, accumulator, or combiner functions must be serially thread-confined. This enables collection to occur in parallel without the Collector needing to implement any additional synchronization. The reduction implementation must manage that the input is properly partitioned, that partitions are processed in isolation, and combining happens only after accumulation is complete.
• For concurrent collectors, an implementation is free to (but not required to) implement reduction concurrently. A concurrent reduction is one where the accumulator function is called concurrently from multiple threads, using the same concurrently-modifiable result container, rather than keeping the result isolated during accumulation. A concurrent reduction should only be applied if the collector has the UNORDERED characteristics or if the originating data is unordered.

除了Collectors的预定义实现Collectors ，静态工厂方法of(Supplier, BiConsumer, BinaryOperator, Characteristics)可用于构建收集器。 例如，您可以创建一个收集器，通过以下方式将小部件累积到TreeSet中：

Collector<Widget, ?, TreeSet<Widget>> intoSet =
         Collector.of(TreeSet::new, TreeSet::add,
                      (left, right) -> { left.addAll(right); return left; });
 

Summary

Public methods

BiConsumer<A, T> accumulator ()

Set<Collector.Characteristics> characteristics ()

BinaryOperator<A> combiner ()

Function<A, R> finisher ()

Collector<T, A, R> of (Supplier<A> supplier, 
                BiConsumer<A, T> accumulator, 
                BinaryOperator<A> combiner, 
                Function<A, R> finisher, 
                Characteristics... characteristics)

Collector<T, R, R> of (Supplier<R> supplier, 
                BiConsumer<R, T> accumulator, 
                BinaryOperator<R> combiner, 
                Characteristics... characteristics)

Supplier<A> supplier ()