Collector解读以及自定义

一、Collector接口解读：　　　　　　

Collector接口解读：

public interface Collector<T, A, R> {
    Supplier<A> supplier();
    BiConsumer<A, T> accumulator();
    BinaryOperator<A> combiner();
    Function<A, R> finisher();
    Set<Characteristics> characteristics();
}

Collector<T, A, R>
T: stream中的元素类型；
A：累加器的类型，可以想象成一个容器。比如T要累加，转化为List<T>，A就是List类型。
R：最终返回值类型
T is the generic type of the items in the stream to be collected.
A is the type of the accumulator, the object on which the partial result will be accumulated during the collection process.
R is the type of the object(typically, but not always, the collection) resulting from the collect operation.

 

二、自定义Collector，看看是怎么实现的

仿照Collectors.toList，自定义实现一个Collector的接口：

package com.cy.java8;

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;

public class ToListCollector<T> implements Collector<T, List<T>, List<T>> {

    private void log(final String s){
        System.out.println(Thread.currentThread().getName() + "-" + s);
    }

    @Override
    public Supplier<List<T>> supplier() {
        log("supplier");
        return ArrayList::new;
    }

    @Override
    public BiConsumer<List<T>, T> accumulator() {
        log("accumulator");
        return (list, v) -> list.add(v);
    }

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

    @Override
    public Function<List<T>, List<T>> finisher() {
        log("finisher");
        return Function.identity();
    }

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

测试执行：

package com.cy.java8;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collector;

public class CustomCollectorAction {

    public static void main(String[] args) {
        Collector<String, List<String>, List<String>> collector = new ToListCollector<>();

        String[] array = new String[]{"Java 8", "Hello", "Collector", "Custom", "Stream"};

        List<String> list1 = Arrays.stream(array).filter(s -> s.length()>5).collect(collector);
        System.out.println(list1);

        List<String> list2 = Arrays.stream(array).parallel().filter(s -> s.length()>5).collect(collector);
        System.out.println(list2);
    }

}

console：

main-supplier
main-accumulator
main-combiner
main-characteristics
main-characteristics
[Java 8, Collector, Custom, Stream]
main-characteristics
main-characteristics
main-supplier
main-accumulator
main-combiner
main-characteristics
main-characteristics
[Java 8, Collector, Custom, Stream]

　　

 

---