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]

　　

---