java8 Collector（收集器）

Collector

什么是Collector

JavaDoc中对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是一种可变的汇聚操作，它将输入元素累积到一个可变的结果容器中。在所有的元素处理完成后，Collector将累积的结果转换成一个最终的表示（这是一个可选的操作）。Collector支持串行和并行两种方式执行。

Collector接口中声明五个方法和一个枚举常量：

public interface Collector {
    Supplier supplier(); 
    BiConsumer accumulator(); 
    BinaryOperator combiner();
    Function finisher();
    Set characteristics();
    enum Characteristics {
        CONCURRENT,
        UNORDERED,
        IDENTITY_FINISH
    }
    ....
}

Collector接口有三个泛型，它们的含义如下：

• T：输入的元素类型
• A：累积结果的容器类型
• R：最终生成的结果类型

Collector工作原理

Collector通过下面四个方法协同工作以完成汇聚操作：

• supplier： 创建新的结果容器
• accumulator：将输入元素合并到结果容器中
• combiner：合并两个结果容器（并行流使用，将多个线程产生的结果容器合并）
• finisher：将结果容器转换成最终的表示

下面是串行流情况下Collector的工作逻辑： 

首先supplier会提供结果容器，然后accumulator向结果容器中累积元素，最后finisher将结果容器转换成最终的返回结果。如果结果容器类型和最终返回结果类型一致，那么finisher就可以不执行，这就是之前说这是一个可选的操作的原因。

而combiner是和并行流相关的，在串行流中combiner并不起作用。JavaDoc中介绍如下：

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.

combiner方法接受两个部分的结果并合并他们，该方法可能会把一个结果容器折叠到另一个结果容器中并返回，也可能返回一个新的结果容器。
 

 假如在并行流中对元素的操作分别在三条线程中完成，三条线程会返回三个结果容器。此时combiner就可能会这样处理多个线程中的结果容器：先将线程2的结果容器2中元素合并到线程1的结果容器1中，并返回结果容器1；再把线程3的结果容器3中的元素合并到线程1的结果容器1中；最后返回结果容器1。

特征值

1. CONCURRENT：表示结果容器只有一个（即使是在并行流的情况下）。只有在并行流且收集器不具备此特性的情况下，combiner()返回的lambda表达式才会执行（中间结果容器只有一个就无需合并）。设置此特性时意味着多个线程可以对同一个结果容器调用，因此结果容器必须是线程安全的。
2. UNORDERED：表示流中的元素无序。
3. IDENTITY_FINISH：表示中间结果容器类型与最终结果类型一致。设置此特性时finiser()方法不会被调用。

自定义Collector

明白Collector的原理之后，我们就可以自定义Collector实现。下面我们完成一个Collector实现——将输入元素收集到Set集合中。

明确需求之后，我们就可以确定下来Collector实现的三个泛型具体是什么：

• T（输入的元素类型）：T
• A（累积结果的容器类型）：Set
• R（最终生成的结果类型）：Set

完成的Collector实现如下：

public class MySetCollector implements Collector, Set> {
 
	@Override
	public Supplier> supplier() {
		System.out.println("supplier invoked");
		return HashSet::new;
	}
 
	@Override
	public BiConsumer, T> accumulator() {
		System.out.println("accumulator invoked");
//		return HashSet::add;   // 报错
		/**
		 * 作为accumulator而言，它能明确的仅仅是supplier提供的结果容器类型是Set类型，
		 * 而不知道supplier提供的具体结果容器类型（这里是HashSet）。
		 * 如果supplier提供的结果容器类型是TreeSet类型，
		 * 那么accumulator使用HashSet提供的add方法就会出错。
		 * 因此这里应该使用Set提供的add方法。
		 */
		return Set::add;
        
	}
 
	@Override
	public BinaryOperator> combiner() {
		System.out.println("combiner invoked");
		return (set1, set2) -> {
			set1.addAll(set2);
			return set1;
		};
	}
 
	@Override
	public Function, Set> finisher() {
		System.out.println("finisher invoked");
		return Function.identity();   // return t -> t; 
	}
 
	@Override
	public Set characteristics() {
		System.out.println("characteristics invoked");
		// 结果容器类型和最终结果类型一致，设置IDENTITY_FINISH特性
		return Collections.unmodifiableSet(EnumSet
				.of(Collector.Characteristics.IDENTITY_FINISH));
	}
	
}

测试我们自定义的Collector实现是否发挥了作用： 

public class TestMyCollector {
	 
	public static void main(String[] args) {
		List data = Arrays.asList("hello", "world", "hello");
		Set result = data.stream().collect(new MySetCollector<>());
		System.out.println(result);
	}
	
}

 打印结果如下：

supplier invoked
accumulator invoked
combiner invoked
characteristics invoked
characteristics invoked
[world, hello]

打印结果是符合我们的预期的，但是从打印结果中，我们可以发现两个问题：

1、“finisher invoked”并没有打印，说明finisher()方法没有被调用。

查看collect()方法实现（位于ReferencePipeline类），我们来看该方法是如何调用Collector的：

public final R collect(Collector collector) {
        A container;
        if (isParallel()       //  这一段是并行流逻辑，可以跳过不看
                && (collector.characteristics().contains(Collector.Characteristics.CONCURRENT))
                && (!isOrdered() || collector.characteristics().contains(Collector.Characteristics.UNORDERED))) {
            container = collector.supplier().get();
            BiConsumer accumulator = collector.accumulator();
            forEach(u -> accumulator.accept(container, u));
        }
        else {
            container = evaluate(ReduceOps.makeRef(collector));    
        }
        return collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)
               ? (R) container
               : collector.finisher().apply(container);
}
 

我们在自定义的Collector实现——MySetCollector中设置了IDENTITY_FINISH特性，通过上面的源码可以知道：如果Collector实现中没有IDENTITY_FINISH特性，才会调用实现类中的finisher()方法，否则直接将中间结果容器强转成最终的结果类型。

因此只有在百分百确定中间结果类型和最终的结果类型一致时，才可以为实现类设置IDENTITY_FINISH特性，否则很可能会出现类型转换异常。

2、"combiner invoked"打印了，然而我们的程序中使用的是串行流。

继续跟进到makeRef()方法中：

public static TerminalOp      // makeRef部分源码
    makeRef(Collector collector) {
        Supplier supplier = Objects.requireNonNull(collector).supplier();
        BiConsumer accumulator = collector.accumulator();
        BinaryOperator combiner = collector.combiner();
         ....  
}
 

从上面的源码中可以看到，makeRef()方法中用一个变量记录调用combiner()方法返回的Lambda表达式，所以"combiner invoked"会被打印，而该Lambda表达式并没有被调用（可以在此Lambda表达式中加入打印语句验证）。