匿名类：

package l8;import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Collectors;public class CollectorToList2 {public static void main(String[] args) {/***<T> – the type of input elements to the reduction operation<A> – the mutable accumulation type of the reduction operation (often hidden as an implementation detail)<R> – the result type of the reduction operation  最终返回结果的类型*/Collector<Integer, List<Integer>, List<String>> toList = new Collector<Integer, List<Integer>, List<String>>() {// 初始一个容器，用于做为累加的容器@Overridepublic Supplier<List<Integer>> supplier() {return () -> new ArrayList<>();}/*** 元素累加* @return*/@Overridepublic BiConsumer<List<Integer>, Integer> accumulator() {return List::add;}/*** 将多个容器进行合并（应该是在并行Stream时使用的）* @return*/@Overridepublic BinaryOperator<List<Integer>> combiner() {return (a, b) -> {System.out.println("combiner call");a.addAll(b);return a;};}/*** 最终类型转换* @return*/@Overridepublic Function<List<Integer>, List<String>> finisher() {return list -> list.stream().map(e -> e + "").collect(Collectors.toList());}@Overridepublic Set<Characteristics> characteristics() {return Collections.singleton(Characteristics.UNORDERED);}};List<String> collect = Arrays.asList(1, 2, 3).stream().collect(toList);System.out.println(collect);collect = Arrays.asList(1, 2, 3).parallelStream().collect(toList);System.out.println(collect);}
}
javascript:void(0)

Combiner:

应用：

优化初始容器的容量：

/*** <T> – the type of input elements to the reduction operation* <A> – the mutable accumulation type of the reduction operation (often hidden as an implementation detail)* <R> – the result type of the reduction operation  最终返回结果的类型*/
class ToListWithInitialCapacity implements Collector<Integer, List<Integer>, List<String>> {private int initialCapacity;public ToListWithInitialCapacity(int initialCapacity) {this.initialCapacity = initialCapacity;}// 初始一个容器，用于做为累加的容器@Overridepublic Supplier<List<Integer>> supplier() {return () -> new ArrayList<>(initialCapacity);}/*** 元素累加** @return*/@Overridepublic BiConsumer<List<Integer>, Integer> accumulator() {return List::add;}/*** 将多个容器进行合并（应该是在并行Stream时使用的）** @return*/@Overridepublic BinaryOperator<List<Integer>> combiner() {return (a, b) -> {System.out.println("combiner call");a.addAll(b);return a;};}/*** 最终类型转换** @return*/@Overridepublic Function<List<Integer>, List<String>> finisher() {return list -> list.stream().map(e -> e + "").collect(Collectors.toList());}@Overridepublic Set<Characteristics> characteristics() {return Collections.singleton(Characteristics.UNORDERED);}
}

Jdk toList默认实现：

    /*** Returns a {@code Collector} that accumulates the input elements into a* new {@code List}. There are no guarantees on the type, mutability,* serializability, or thread-safety of the {@code List} returned; if more* control over the returned {@code List} is required, use {@link #toCollection(Supplier)}.** @param <T> the type of the input elements* @return a {@code Collector} which collects all the input elements into a* {@code List}, in encounter order*/public static <T>Collector<T, ?, List<T>> toList() {return new CollectorImpl<>(ArrayList::new, List::add,(left, right) -> { left.addAll(right); return left; },CH_ID);}