2020了你还不会Java8新特性？（四）Collector类源码分析

Collector类源码分析

jdk8是怎么对底层完成支持的。不了解底层，平时用还可以，但是遇到问题的时候就会卡在那里。迟迟灭有解决方案。在学习一门新技术时，先学习怎么去用，不要执着于源码。但是随着用的越来越多，你去了解底层是比较好的一种学习方法。

有多种方法可以实现同一个功能.什么方式更好呢? 越具体的方法越好.   减少自动装箱拆箱操作

1. collect : 收集器
2. Collector作为collect方法的参数。
3. Collector作为一个接口。它是一个可变的汇聚操作，将输入元素累计到一个可变的结果容器中；它会在所有元素都处理完毕后将累计的结果作为一个最终的表示（这是一个可选操作）；它支持串行与并行两种方式执行。（并不是说并行一定比串行快。）
4. Collects本身提供了关于Collectoe的常见汇聚实现，Collectors本身实际上是一个工厂。
5. 为了确保串行和并行的结果一致，需要进行额外的处理。必须要满足两个约束。
   identity 同一性
   associativity 结合性
6. 同一性：对于任何一条并行线路来说 ，需要满足a == combiner.apply(a, supplier.get())。举例来说：
   （List list1,List list2 -> {list1.addAll(list2);return list1}）
   结合性： 下方有举例。

Collector收集器的实现源码详解

/**
 * A mutable reduction operation that
 * accumulates input elements into a mutable result container, optionally transforming
 * the accumulated result into a final representation after all input elements
 * have been processed.  Reduction operations can be performed either sequentially
 * or in parallel.
 
    Collector作为一个接口。它是一个可变的汇聚操作，将输入元素累计到一个可变的结果容器中；它会在所有元素都处理   完毕后将累计的结果作为一个最终的表示（这是一个可选操作）；它支持串行与并行两种方式执行。（并不是说并行一定比串行快。）
  
 * 
Examples of mutable reduction operations include:
 * accumulating elements into a {@code Collection}; concatenating
 * strings using a {@code StringBuilder}; computing summary information about
 * elements such as sum, min, max, or average; computing "pivot table" summaries
 * such as "maximum valued transaction by seller", etc.  The class {@link Collectors}
 * provides implementations of many common mutable reductions.
 
 Collects本身提供了关于Collectoe的常见汇聚实现，Collectors本身实际上是一个工厂。
 
 * 
A {@code Collector} is specified by four functions that work together to
 * accumulate entries into a mutable result container, and optionally perform
 * a final transform on the result.  They are: 

 *     
creation of a new result container ({@link #supplier()})
 *     
incorporating a new data element into a result container ({@link #accumulator()})
 *     
combining two result containers into one ({@link #combiner()})
 *     
performing an optional final transform on the container ({@link #finisher()})
 * 
 
    Collector 包含了4个参数
 
 * 
Collectors also have a set of characteristics, such as
 * {@link Characteristics#CONCURRENT}, that provide hints that can be used by a
 * reduction implementation to provide better performance.
 *
 * 
A sequential implementation of a reduction using a collector would
 * create a single result container using the supplier function, and invoke the
 * accumulator function once for each input element.  A parallel implementation
 * would partition the input, create a result container for each partition,
 * accumulate the contents of each partition into a subresult for that partition,
 * and then use the combiner function to merge the subresults into a combined
 * result.
 
   举例说明： 
  1，2， 3， 4     四个部分结果。
  1，2 -》 5  
  5，3 -》 6
  6，4 -》 6  
 
 
 ### 同一性和结合性的解析： 
 
 * 
To ensure that sequential and parallel executions produce equivalent
 * results, the collector functions must satisfy an identity and an
 * associativity constraints.
 
 为了确保串行和并行的结果一致，需要进行额外的处理。必须要满足两个约束。
             identity 同一性
                associativity  结合性
 
 * 
The identity constraint says that for any partially accumulated result,
 * combining it with an empty result container must produce an equivalent
 * result.  That is, for a partially accumulated result {@code a} that is the
 * result of any series of accumulator and combiner invocations, {@code a} must
 * be equivalent to {@code combiner.apply(a, supplier.get())}.
  
    同一性： 对于任何一条并行线路来说,需要满足a == combiner.apply(a, supplier.get())
 
 * 
The associativity constraint says that splitting the computation must
 * produce an equivalent result.  That is, for any input elements {@code t1}
 * and {@code t2}, the results {@code r1} and {@code r2} in the computation
 * below must be equivalent:
 * 
{@code
 *     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
 * } 
 
 结合性： 如上例。  最终要求 r1 == r2 
 
 * 
For collectors that do not have the {@code UNORDERED} characteristic,
 * two accumulated results {@code a1} and {@code a2} are equivalent if
 * {@code finisher.apply(a1).equals(finisher.apply(a2))}.  For unordered
 * collectors, equivalence is relaxed to allow for non-equality related to
 * differences in order.  (For example, an unordered collector that accumulated
 * elements to a {@code List} would consider two lists equivalent if they
 * contained the same elements, ignoring order.)

 对于无序的收集器来说，等价性就被放松了，会考虑到顺序上的区别对应的不相等性。
 两个集合中包含了相同的元素，但是忽略了顺序。这种情况下两个的集合也是等价的。
 
 
 ### collector复合与注意事项：
 
 * 
Libraries that implement reduction （汇聚） based on {@code Collector}, such as
 * {@link Stream#collect(Collector)}, must adhere to the following constraints:
 * 
  
 *     
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.
 
            如果一个结果被传递给combiner or finisher，但是并没有返回一个你传递的对象，说明你生成了一个新的结果或者创建了新的对象。这个结果就不会再被使用了。
            
 *     
Once a result is passed to the combiner or finisher function, it
 *     is never passed to the accumulator function again.
 
                一旦一个结果被传递给了 combiner or finisher 函数，他就不会再被传递给了accumulator函数了。
 
 *     
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 {@code 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
 *     {@link Characteristics#UNORDERED} characteristics or if the
 *     originating data is unordered.
    
            如果不是并发收集器，4个线程会生成4个中间结果。
            是并发收集器的话，4个线程会同时调用一个结果容器。
 
 * 
 *
 * 
In addition to the predefined implementations in {@link Collectors}, the
 * static factory methods {@link #of(Supplier, BiConsumer, BinaryOperator, Characteristics...)}
 * can be used to construct collectors.  For example, you could create a collector
 * that accumulates widgets into a {@code TreeSet} with:
 *
 * 
{@code
 *     Collector> intoSet =
 *         Collector.of(TreeSet::new, TreeSet::add,
 *                      (left, right) -> { left.addAll(right); return left; });
 * }
 
 通过Collector.of（传进一个新的要操作的元素，结果容器处理的步骤，多线程处理的操作）
 将流中的每个Widget 添加到TreeSet中
 
 
 * (This behavior is also implemented by the predefined collector
 * {@link Collectors#toCollection(Supplier)}).
 *
 * @apiNote  
 * Performing a reduction operation with a {@code Collector} should produce a
 * result equivalent to:
 * 
{@code
 *     R container = collector.supplier().get();
 *     for (T t : data)
 *         collector.accumulator().accept(container, t);
 *     return collector.finisher().apply(container);
 * }
 
    api的说明：  collector的finisher汇聚的实现过程。
 
 * 
However, the library is free to partition the input, perform the reduction
 * on the partitions, and then use the combiner function to combine the partial
 * results to achieve a parallel reduction.  (Depending on the specific reduction
 * operation, this may perform better or worse, depending on the relative cost
 * of the accumulator and combiner functions.)
 
 性能取决于accumulator and combiner的代价。  也就是说 并行流 并不一定比串行流效率高。
 
 * 
Collectors are designed to be composed; many of the methods
 * in {@link Collectors} are functions that take a collector and produce
 * a new collector.  For example, given the following collector that computes
 * the sum of the salaries of a stream of employees:
 * 
{@code
 *     Collector summingSalaries
 *         = Collectors.summingInt(Employee::getSalary))
 * }
 
  搜集器是可以组合的：  take a collector and produce a new collector.  
  搜集器的实现过程。  如  员工的工资的求和。
 
 * If we wanted to create a collector to tabulate the sum of salaries by
 * department, we could reuse the "sum of salaries" logic using
 * {@link Collectors#groupingBy(Function, Collector)}:
 * 
{@code
 *     Collector> summingSalariesByDept
 *         = Collectors.groupingBy(Employee::getDepartment, summingSalaries);
 * }
 
 如果我们想要新建一个搜集器，我们可以复用之前的搜集器。
 实现过程。
 
 * @see Stream#collect(Collector)
 * @see Collectors
 *
 * @param  the type of input elements to the reduction operation
              代表 流中的每一个元素的类型。
 * @param  the mutable accumulation type of the reduction operation (often
 *            hidden as an implementation detail)
              代表 reduction操作的可变容器的类型。表示中间操作生成的结果的类型（如ArrayList）。
 * @param  the result type of the reduction operation
              代表 结果类型
 * @since 1.8
 */
public interface Collector{
   /**
     * A function that creates and returns a new mutable result container.
     *  A就代表每一次返回结果的类型
     * @return a function which returns a new, mutable result container
     */
    Supplier supplier();   // 提供一个结果容器
    
    /**
     * A function that folds a value into a mutable result container.
     *  A代表中间操作返回结果的类型。 T是下一个代操作的元素的类型。
     * @return a function which folds a value into a mutable result container
     */
    BiConsumer accumulator();    //不断的向结果容器中添加元素。

    /**
     * A function that accepts two partial results and merges them.  The
     * combiner function may fold state from one argument into the other and
     * return that, or may return a new result container.
     *  A 中间操作返回结果的类型。
     * @return a function which combines two partial results into a combined
     * result
     */
    BinaryOperator combiner();   //在多线程中  合并 部分结果。 
  /**
  和并行流紧密相关的
    接收两个结果，将两个部分结果合并到一起。
  combiner函数，有4个线程同时去执行，那么就会有生成4个部分结果。
  
  举例说明： 
  1，2， 3， 4     四个部分结果。
  1，2 -》 5  
  5，3 -》 6
  6，4 -》 6  
   1,2合并返回5  属于return a new result container. 
   6,4合并返回6，属于The combiner function may fold state from one argument into the other and  return that。
   */

    /**
     * Perform the final transformation from the intermediate accumulation type
     * {@code A} to the final result type {@code R}.
     *R 是最终返回结果的类型。
     * 
If the characteristic {@code IDENTITY_TRANSFORM} is
     * set, this function may be presumed to be an identity transform with an
     * unchecked cast from {@code A} to {@code R}.
     * 
     * @return a function which transforms the intermediate result to the final
     * result
     */
    Function finisher();  //  合并中间的值，给出返回值。
  
    /**
     * Returns a {@code Set} of {@code Collector.Characteristics} indicating
     * the characteristics of this Collector.  This set should be immutable.
     *
     * @return an immutable set of collector characteristics
     */
    Set characteristics();   //特征的集合

    /**
     * Returns a new {@code Collector} described by the given {@code supplier},
     * {@code accumulator}, and {@code combiner} functions.  The resulting
     * {@code Collector} has the {@code Collector.Characteristics.IDENTITY_FINISH}
     * characteristic.
     *
     * @param supplier The supplier function for the new collector
     * @param accumulator The accumulator function for the new collector
     * @param combiner The combiner function for the new collector
     * @param characteristics The collector characteristics for the new
     *                        collector
     * @param  The type of input elements for the new collector
     * @param  The type of intermediate accumulation result, and final result,
     *           for the new collector
     * @throws NullPointerException if any argument is null
     * @return the new {@code Collector}
     */
    public static Collector of(Supplier supplier,
                                              BiConsumer accumulator,
                                              BinaryOperator combiner,
                                              Characteristics... characteristics) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(accumulator);
        Objects.requireNonNull(combiner);
        Objects.requireNonNull(characteristics);
        Set cs = (characteristics.length == 0)
                                  ? Collectors.CH_ID
                                  : Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH,
                                                                           characteristics));
        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, cs);
    }

    /**
     * Returns a new {@code Collector} described by the given {@code supplier},
     * {@code accumulator}, {@code combiner}, and {@code finisher} functions.
     *
     * @param supplier The supplier function for the new collector
     * @param accumulator The accumulator function for the new collector
     * @param combiner The combiner function for the new collector
     * @param finisher The finisher function for the new collector
     * @param characteristics The collector characteristics for the new
     *                        collector
     * @param  The type of input elements for the new collector
     * @param  The intermediate accumulation type of the new collector
     * @param  The final result type of the new collector
     * @throws NullPointerException if any argument is null
     * @return the new {@code Collector}
     */
    public static Collector of(Supplier supplier,
                                                 BiConsumer accumulator,
                                                 BinaryOperator combiner,
                                                 Function finisher,
                                                 Characteristics... characteristics) {
        Objects.requireNonNull(supplier);
        Objects.requireNonNull(accumulator);
        Objects.requireNonNull(combiner);
        Objects.requireNonNull(finisher);
        Objects.requireNonNull(characteristics);
        Set cs = Collectors.CH_NOID;
        if (characteristics.length > 0) {
            cs = EnumSet.noneOf(Characteristics.class);
            Collections.addAll(cs, characteristics);
            cs = Collections.unmodifiableSet(cs);
        }
        return new Collectors.CollectorImpl<>(supplier, accumulator, combiner, finisher, cs);
    }

    /**
     * Characteristics indicating properties of a {@code Collector}, which can
     * be used to optimize reduction implementations.
     */
    enum Characteristics {  // 特征 
        /**
         * Indicates that this collector is concurrent, meaning that
         * the result container can support the accumulator function being
         * called concurrently with the same result container from multiple
         * threads.
         *
         * 
If a {@code CONCURRENT} collector is not also {@code UNORDERED},
         * then it should only be evaluated concurrently if applied to an
         * unordered data source.
         */
        CONCURRENT,

        /**
         * Indicates that the collection operation does not commit to preserving
         * the encounter order of input elements.  (This might be true if the
         * result container has no intrinsic order, such as a {@link Set}.)
         */
        UNORDERED,

        /**
         * Indicates that the finisher function is the identity function and
         * can be elided.  If set, it must be the case that an unchecked cast
         * from A to R will succeed.
         */
        IDENTITY_FINISH
    }
}

本文是针对collect类源码的详解。必要的中文总结的感觉挺好的。有错误的地方欢迎指出。嘿嘿。一起慢慢成长哦。