自定义Collector

在Java8的特性中，使用了新的API,其中就有Stream，在偶然的机会下看到思否大佬对自定义Collector写下的文章，惊为天人。

public static <T>
Collector<T, ?, List<T>> toList() {
    return new CollectorImpl<>((Supplier<List<T>>) ArrayList::new, List::add,
                               (left, right) -> { left.addAll(right); return left; },
                               CH_ID);
}

自定义收集器需要实现Collector接口，其中包含5个Function接口

package function;

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;

/**
 * @Description 自定义收集器
 * @Authror taren
 * @DATE 2019/7/5 9:24
 */
public class CustomCollectors {

public static <T> Collector<T, List<List<T>>, List<List<T>>> groupByNumber() {
    return CustomCollectors.groupByNumber(2);
}

public static <T> Collector<T, List<List<T>>, List<List<T>>> groupByNumber(int number) {
    return new NumberCustomCollector(number);
}

public static class NumberCustomCollector<T> implements Collector<T, List<List<T>>, List<List<T>>> {

    private int number;

    public NumberCustomCollector(int number) {
        this.number = number;
    }
    //传入一个泛型 List<T> -> new ArrayList<T>
    //Supplier<T> 传入一个泛型  得到一个泛型的类型  T get()
    @Override
    public Supplier<List<List<T>>> supplier() {
        return ArrayList::new;
    }

    //BiConsumer<T,R> -> void accept(T,R) 实现累加器
    @Override
    public BiConsumer<List<List<T>>, T> accumulator() {
        return (list, item) -> {
            if (list.isEmpty()) {
                list.add(this.createNewList(item));
            } else {
                List<T> last = (List<T>) list.get(list.size() - 1);
                if (last.size() < number) {
                    last.add(item);
                } else {
                    list.add(this.createNewList(item));
                }
            }
        };
    }

    //组合  R apply(T t, U u)  2个类型组合成另外一个新的类型
    @Override
    public BinaryOperator<List<List<T>>> combiner() {
        return (list1, list2) -> {
            list1.addAll(list2);
            return list1;
        };
    }

    // 用自身 就是t->t 还是本身的类型 不是t->other
    @Override
    public Function<List<List<T>>, List<List<T>>> finisher() {
        return Function.identity();
    }

    // 表示 Function.identity() 就是收集的最终类型 不再做最终的转换
    @Override
    public Set<Characteristics> characteristics() {
        return Collections.unmodifiableSet(EnumSet.of(Collector.Characteristics.IDENTITY_FINISH));
    }

    private List<T> createNewList(T item) {
        List<T> newOne = new ArrayList<T>();
        newOne.add(item);
        return newOne;
    }
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
    // 按照2个分组
    List<List<Integer>> twoNumberList = list.stream().collect(CustomCollectors.groupByNumber());
    // 按照5个分组
    List<List<Integer>> fiveNumberList = list.stream().collect(CustomCollectors.groupByNumber(5));

    System.out.println(twoNumberList);
    System.out.println(fiveNumberList);
}
}

Supplier是一个FunctionInterface,表达是的提供一个初始化的容器，但在这里是创建一个累加器，即

List list=new ArrayList<>()

BiConsumer是把一个类型的东西添加到累加器中，即是

list.add(item)

BinaryOperator是把一个累加器和另一个累加器合并到一起，即是

list.add(otherList)

Function是把一个结果转化为另外一个结果，但是在这里是

t->t

Set<Characteristics>是一个枚举类，在这里表示Function转化的就是最终的结果