自定义收集器

一 概述

 Collector是收集器接口，自定义的收集器需要实现此接口，实现其系列方法。该接口的方法有supplier(),accumulator(),combiner(),finisher()和characteristics()。
 Supplier< A > supplier():A类型是收集器中间容器的类型，该方法用于创建并返回一个新的中间结果容器。
 BiConsumer<A, T> accumulator():BiConsumer接受两个参数，不返回结果。A类型是收集器中间容器的类型，T类型是流中元素的类型。该方法将一个元素添加至中间容器中。
 BinaryOperator< A > combiner():BinaryOperator接受两个参数，返回一个结果。A类型是中间容器的类型。该方法将俩个参数的中间容器合并，该方法合并的方法有两种：第一种将两个参数的状态合并至其中一个并返回，比如listA和listB，将listB的元素添加至listA中，并将listA返回。第二种创建一个新的中间容器。比如listA和listB，该方案创建listC，listC中包含了listA和listB的所有元素，并将listC返回。
 Function<A, R> finisher():Function接受一个参数，返回一个结果。A类型是中间容器的类型，R类型就是声明的结果容器类型。该方法执行一个A类型至R类型的转换。假如该实现设置了IDENTITY_TRANSFORM，将会执行一个A到R的强制类型转换。
 Set<Characteristics> characteristics():该方法设置自定义收集器的特点。Characteristics是一个枚举类，包含的特征有CONCURRENT、UNORDERED、IDENTITY_FINISH。
  IDENTITY_FINISH:表明finisher()是恒等的，如果设置了此特征，finisher()的lambda体将不会执行。
  CONCURRENT:表明收集器是并行的，多线程并行的执行accumulator(),执行的对象是同一个中间容器。如果设置了此特征只会有一个中间结果容器。
  UNORDERED:表明收集是无序的。

二 实例

将元素收集至Set中，中间容器和结果容器都是Set

public class MyCollector<T> implements Collector<T, Set<T>, Set<T>> {

    @Override
    public Supplier<Set<T>> supplier() {
        System.out.println("supplier invoke");
        return TreeSet::new;//中间容器为TreeSet
    }

    @Override
    public BiConsumer<Set<T>, T> accumulator() {
        System.out.println("accumulator invoke");
        return Set::add;//收集的方式是添加元素
    }

    @Override
    public BinaryOperator<Set<T>> combiner() {
        System.out.println("combiner invoke");
        return (left, right) -> {//中间容器合并的方式为状态叠加
            left.addAll(right);
            return left;
        };
    }

    @Override
    public Function<Set<T>, Set<T>> finisher() {
        System.out.println("finisher invoke");
        return Function.identity();//将收集结果直接输出
    }

    @Override
    public Set<Characteristics> characteristics() {
        System.out.println("characteristics invoke");
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.IDENTITY_FINISH));
        
       IDENTITY_FINISH:表明finisher()是恒等的，如果设置了此特征，finisher()的lambda体将不会执行。
       
       CONCURRENT:表明收集器是并行的，多线程并行的执行accumulator(),执行的对象是同一个中间容器。如果设置了此特征只会有一个中间结果容器。
       
       UNORDERED:表明收集是无序的。
        
    }
}

public class Test {
    public static void main(String[] args) {

        List<String> stringList = Arrays.asList("Hello", "World", "Hello World", "Hello", "a", "ab");
        Set<String> stringSet=new TreeSet<>();
        stringSet.addAll(stringList);

        stringSet.stream()
                .collect(new MyCollector<>());
    }
}

//执行结果是
supplier invoke
accumulator invoke
combiner invoke
characteristics invoke
characteristics invoke  
//我们发现 finisher的lambda并未执行

//如果特征值不包含 IDENTITY_FINISH 在看执行结果
supplier invoke
accumulator invoke
combiner invoke
characteristics invoke
characteristics invoke
finisher invoke //调用了lambda
finisher lambda


源码执行流程如下：
 public final <R, A> R collect(Collector<? super P_OUT, A, R> collector) {
        A container; //中间结果容器的类型
        if (isParallel()
                && (collector.characteristics().contains(Collector.Characteristics.CONCURRENT))
                && (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) {
            container = collector.supplier().get();
            BiConsumer<A, ? super P_OUT> accumulator = collector.accumulator();
            forEach(u -> accumulator.accept(container, u));
        }
        else {
            container = evaluate(ReduceOps.makeRef(collector));
        }
        return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH) //如果包含了IDENTITY_FINISH特征
               ? (R) container //这里直接强制类型转换
               : collector.finisher().apply(container); //如果不包含 则运行finisher的lambda
    }
    
如果设置了特征值CONCURRENT，不管是串行流还是并行流结果容器都是一个，因此需要注意集合的遍历与修改异常

将元素收集至Map中，中间容器为Set

public class StringCollector<T> implements Collector<T, Set<T>, Map<T, T>> {

    @Override
    public Supplier<Set<T>> supplier() {
        return HashSet::new;//中间容器
    }

    @Override
    public BiConsumer<Set<T>, T> accumulator() {
        return Set::add;
    }

    @Override
    public BinaryOperator<Set<T>> combiner() {
        return (left, right) -> {
            left.addAll(right);
            return left;
        };
    }

    @Override
    public Function<Set<T>, Map<T, T>> finisher() {
        return (set) -> {//将中间容器转为结果Map
            Map<T, T> map = new HashMap<>();
            set.forEach(it -> map.put(it, it));
            return map;
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Characteristics.UNORDERED));//如果将特征值改为IDENTITY_FINISH则会发生强制类型转换异常
    }
}