自定義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轉化的就是最終的結果