Collector 类源码分析
jdk8 是怎么对底层完成支持的. 不了解底层, 平时用还可以, 但是遇到问题的时候就会卡在那里. 迟迟灭有解决方案. 在学习一门新技术时, 先学习怎么去用, 不要执着于源码. 但是随着用的越来越多, 你去了解底层是比较好的一种学习方法.
有多种方法可以实现同一个功能. 什么方式更好呢? 越具体的方法越好. 减少自动装箱拆箱操作
collect : 收集器
Collector 作为 collect 方法的参数.
Collector 作为一个接口. 它是一个可变的汇聚操作, 将输入元素累计到一个可变的结果容器中; 它会在所有元素都处理完毕后将累计的结果作为一个最终的表示 (这是一个可选操作); 它支持串行与并行两种方式执行.(并不是说并行一定比串行快.)
Collects 本身提供了关于 Collectoe 的常见汇聚实现, Collectors 本身实际上是一个工厂.
为了确保串行和并行的结果一致, 需要进行额外的处理. 必须要满足两个约束.
identity 同一性
associativity 结合性
同一性: 对于任何一条并行线路来说 , 需要满足 a == combiner.apply(a, supplier.get()). 举例来说:
(List list1,List list2 -> {list1.addAll(list2);return list1})
结合性: 下方有举例.
Collector 收集器的实现源码详解
- /**
- * A <a href="package-summary.html#Reduction">mutable reduction operation</a> 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 作为一个接口. 它是一个可变的汇聚操作, 将输入元素累计到一个可变的结果容器中; 它会在所有元素都处理 完毕后将累计的结果作为一个最终的表示 (这是一个可选操作); 它支持串行与并行两种方式执行.(并不是说并行一定比串行快.)
- * <p>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 本身实际上是一个工厂.
- * <p>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: <ul>
- * <li>creation of a new result container ({@link #supplier()})</li>
- * <li>incorporating a new data element into a result container ({@link #accumulator()})</li>
- * <li>combining two result containers into one ({@link #combiner()})</li>
- * <li>performing an optional final transform on the container ({@link #finisher()})</li>
- * </ul>
- Collector 包含了 4 个参数
- * <p>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.
- *
- * <p>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
- ### 同一性和结合性的解析:
- * <p>To ensure that sequential and parallel executions produce equivalent
- * results, the collector functions must satisfy an <em>identity</em> and an
- * <a href="package-summary.html#Associativity">associativity</a> constraints.
- 为了确保串行和并行的结果一致, 需要进行额外的处理. 必须要满足两个约束.
- identity 同一性
- associativity 结合性
- * <p>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())
- * <p>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:
- * <pre>{@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
- * } </pre>
- 结合性: 如上例. 最终要求 r1 == r2
- * <p>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 复合与注意事项:
- * <p>Libraries that implement reduction (汇聚) based on {@code Collector}, such as
- * {@link Stream#collect(Collector)}, must adhere to the following constraints:
- * <ul>
- * <li>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.</li>
- * <li>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.</li>
- 具体的实现来说, 不应该对中间返回的结果进行额外的操作. 除了最终的返回的结果.
- * <li>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.</li>
- 如果一个结果被传递给 combiner or finisher, 但是并没有返回一个你传递的对象, 说明你生成了一个新的结果或者创建了新的对象. 这个结果就不会再被使用了.
- * <li>Once a result is passed to the combiner or finisher function, it
- * is never passed to the accumulator function again.</li>
- 一旦一个结果被传递给了 combiner or finisher 函数, 他就不会再被传递给了 accumulator 函数了.
- * <li>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.</li>
- 线程和线程之间的处理都是独立的, 最终结束时再进行合并.
- * <li>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.</li>
- 如果不是并发收集器, 4 个线程会生成 4 个中间结果.
- 是并发收集器的话, 4 个线程会同时调用一个结果容器.
- * </ul>
- *
- * <p>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:
- *
- * <pre>{@code
- * Collector<Widget, ?, TreeSet<Widget>> intoSet =
- * Collector.of(TreeSet::new, TreeSet::add,
- * (left, right) -> { left.addAll(right); return left; });
- * }</pre>
- 通过 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:
- * <pre>{@code
- * R container = collector.supplier().get();
- * for (T t : data)
- * collector.accumulator().accept(container, t);
- * return collector.finisher().apply(container);
- * }</pre>
- API 的说明: collector 的 finisher 汇聚的实现过程.
- * <p>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 的代价. 也就是说 并行流 并不一定比串行流效率高.
- * <p>Collectors are designed to be <em>composed</em>; 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:
- * <pre>{@code
- * Collector<Employee, ?, Integer> summingSalaries
- * = Collectors.summingInt(Employee::getSalary))
- * }</pre>
- 搜集器是可以组合的: 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)}:
- * <pre>{@code
- * Collector<Employee, ?, Map<Department, Integer>> summingSalariesByDept
- * = Collectors.groupingBy(Employee::getDepartment, summingSalaries);
- * }</pre>
- 如果我们想要新建一个搜集器, 我们可以复用之前的搜集器.
- 实现过程.
- * @see Stream#collect(Collector)
- * @see Collectors
- *
- * @param <T> the type of input elements to the reduction operation
- <T> 代表 流中的每一个元素的类型.
- * @param <A> the mutable accumulation type of the reduction operation (often
- * hidden as an implementation detail)
- <A> 代表 reduction 操作的可变容器的类型. 表示中间操作生成的结果的类型 (如 ArrayList).
- * @param <R> the result type of the reduction operation
- <R> 代表 结果类型
- * @since 1.8
- */
- public interface Collector <T,
- A,
- R> {
- /**
- * A function that creates and returns a new mutable result container.
- * A 就代表每一次返回结果的类型
- * @return a function which returns a new, mutable result container
- */
- Supplier <A> 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 <A,
- T> 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 <A> 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 是最终返回结果的类型.
- * <p>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 <A,
- R> 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> 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 <T> The type of input elements for the new collector
- * @param <R> 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 <T,
- R> Collector <T,
- R,
- R> of(Supplier <R> supplier, BiConsumer <R, T> accumulator, BinaryOperator <R> combiner, Characteristics...characteristics) {
- Objects.requireNonNull(supplier);
- Objects.requireNonNull(accumulator);
- Objects.requireNonNull(combiner);
- Objects.requireNonNull(characteristics);
- Set <Characteristics> 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 <T> The type of input elements for the new collector
- * @param <A> The intermediate accumulation type of the new collector
- * @param <R> The final result type of the new collector
- * @throws NullPointerException if any argument is null
- * @return the new {@code Collector}
- */
- public static <T,
- A,
- R> Collector <T,
- A,
- R> of(Supplier <A> supplier, BiConsumer <A, T> accumulator, BinaryOperator <A> combiner, Function <A, R> finisher, Characteristics...characteristics) {
- Objects.requireNonNull(supplier);
- Objects.requireNonNull(accumulator);
- Objects.requireNonNull(combiner);
- Objects.requireNonNull(finisher);
- Objects.requireNonNull(characteristics);
- Set <Characteristics> 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 <em>concurrent</em>, meaning that
- * the result container can support the accumulator function being
- * called concurrently with the same result container from multiple
- * threads.
- *
- * <p>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 类源码的详解. 必要的中文总结的感觉挺好的. 有错误的地方欢迎指出. 嘿嘿. 一起慢慢成长哦.
来源: http://www.bubuko.com/infodetail-3365917.html