自定义Collector

2020-02-19

Collector 接口

Collectors类提供了很多工具方法，我们也可以自己实现Collector接口自定义Collector.

Collector 定义

Collector 提供接口的定义public interface Collector<T, A, R>,有三个泛型T、A、R

T:元素类型
A:归约运算的可变累积类型
R:结果类型

Collector 抽象方法

Collector包含5个抽象方法supplier()、accumulator()、combiner()、finisher()、characteristics()

supplier()：建立新的结果容器
accumulator():将元素添加到结果容器
combiner():并行处理
finisher():对结果容器应用最终转换
characteristics():表明这个Collector的特点，有三个枚举值
- CONCURRENT：是否可以并发
- UNORDERED：是否允许无序
- IDENTITY_FINISH：是否执行`finisher()对结果容器进行转换，如果存在该枚举则，会直接将泛型A强制转为泛型R

Collector 执行逻辑

Collector 方法执行的逻辑

创建初始化容器 A accumulator = colelctor.supplier().get()
将元素放入到初始化的容器当中collector.accumulator().accept(accmulator,next)
判断是否有下一个元素，如果存在则 T next = 取流中的下一个元素
转换结果R result = collector.finisher().apply(accumulator())
返回结果return result

`combiner` 方法

combiner方法会返回一个供归约操作的函数，它定义了对流的各个子部分进行并行处理时，各个子部分归约所得的累加器要如何合并。

该方法会用到java7中引入的fork/join框架和spliterator抽象

原始流会以递归方式拆分为子流，直到定义流是否需要进一步拆分的一个条件
现在，所有的子流都可以并行处理
最后，使用收集器combiner()方法返回的函数，将所有部分结果都两两合并。这时会把原始流每次拆分时得到的子流对应的结果合并起来

自定义实现 `Collector`

package com.bycsmys.character6;

import com.bycsmys.model.User;
import com.bycsmys.util.ModelUtil;

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;

/**
 * @Author wangqd
 * @DATE 2020-02-18
 */
public class CollectorTest {


    public static void main(String[] args) {
        List<User> users = ModelUtil.initUser();
        users.parallelStream().collect(new Test<User>());

    }

    /**
     * Collector<T, A, R>
     *  T: 元素类型
     *  A: 归约运算的可变累积类型
     *  R: 结果类型
     * @param <T>
     */
    public static class Test<T> implements Collector<T, List<T>, List<T>> {

        /**
         * 建立新的结果容器
         *
         * @return
         */
        @Override
        public Supplier<List<T>> supplier() {
            System.out.println("Supplier");
            return ArrayList::new;
        }

        /**
         * 将元素添加到结果容器
         * 返回执行归约操作的函数。当遍历到流中第n个元素时，这个函数执行时，
         * 会有两个参数：保存归约结果的累加器（以收集了流中的前n-1个项目），还有第n个元素本身
         *
         * @return
         */
        @Override
        public BiConsumer<List<T>, T> accumulator() {
            System.out.println("accumulator");
            return List::add;
        }

        @Override
        public BinaryOperator<List<T>> combiner() {
            System.out.println("combiner");
            return (list1,list2) ->{
                list1.addAll(list2);
                return list1;
            };
        }

        /**
         * 对结果容器应用最终转换
         * @return
         */
        @Override
        public Function<List<T>, List<T>> finisher() {
            System.out.println("finisher");
            return Function.identity();
        }

        @Override
        public Set<Characteristics> characteristics() {
            return Collections.unmodifiableSet(EnumSet.of(Characteristics.CONCURRENT, Characteristics.IDENTITY_FINISH));
        }
    }
}