java8学习之groupingBy源码分析

继续接着上一次【http://www.cnblogs.com/webor2006/p/8366083.html】来分析Collectors中的各种收集器的实现，对里它里面有个groupingby()方法，这个之前咱们也已经对它详细使用过，但是！！它的实现是比较复杂的，所以这次来仔细分析一下该方法的实现细节，纵览一下它，存在几个重载方式：

先来从最基础的开始分析，如下：

其中先来看一下该方法返回值所携带泛型的含义：

接着看下方法的参数，既提供一个分类器：

接着方法的实现是调用了另外一个groupingBy()：

那像这种有下游收集器的方法实现的一个大致思路是怎样的呢？downstream既然已经是一个收集器了，所以就会有收集器的那几个重要的方法，而还有一个分类器参数，其实就是将这个分类器应用到这个下游收集器当中，使得收集器进行了一系列的转换，而最终转换成的收集器则就是方法要返回的收集器啦，所以但凡方法中带有一个收集器然后又返回一个收集器其构造思路都类似。

目前这个groupingBy()有四个泛型了，下面先来对每个泛型有个认知：

接着再来看这个方法的具体实现，发现又调用了另外一个groupingBy()方法，如下：

而可以看到第二个参数实例化了一个HashMap对象，先不去看它所调用的另外一个重载groupingBy()方法的定义，从这个字面就能知道第二个参数肯定是做为最终的结果容器对象，所以说如果咱们在使用时是使用了第一个最简单的groupingBy()来对数据进行分组，最终返回的肯定是HashMap对象，而如果咱们想自己定义最终返回的类型比如：TreeMap，那这时就得使用最复杂的最后一个groupingBy()方法啦，所以下面将焦点转移到这个最复杂方法上面，先来贴出这个方法的实现先来感受一下其复杂性：

public static <T, K, D, A, M extends Map<K, D>>
    Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                                  Supplier<M> mapFactory,
                                  Collector<? super T, A, D> downstream) {
        Supplier<A> downstreamSupplier = downstream.supplier();
        BiConsumer<A, ? super T> downstreamAccumulator = downstream.accumulator();
        BiConsumer<Map<K, A>, T> accumulator = (m, t) -> {
            K key = Objects.requireNonNull(classifier.apply(t), "element cannot be mapped to a null key");
            A container = m.computeIfAbsent(key, k -> downstreamSupplier.get());
            downstreamAccumulator.accept(container, t);
        };
        BinaryOperator<Map<K, A>> merger = Collectors.<K, A, Map<K, A>>mapMerger(downstream.combiner());
        @SuppressWarnings("unchecked")
        Supplier<Map<K, A>> mangledFactory = (Supplier<Map<K, A>>) mapFactory;

        if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
            return new CollectorImpl<>(mangledFactory, accumulator, merger, CH_ID);
        }
        else {
            @SuppressWarnings("unchecked")
            Function<A, A> downstreamFinisher = (Function<A, A>) downstream.finisher();
            Function<Map<K, A>, M> finisher = intermediate -> {
                intermediate.replaceAll((k, v) -> downstreamFinisher.apply(v));
                @SuppressWarnings("unchecked")
                M castResult = (M) intermediate;
                return castResult;
            };
            return new CollectorImpl<>(mangledFactory, accumulator, merger, finisher, CH_NOID);
        }
    }