java-stream-泛型

一、测试代码

    public static void main(String[] args) {
        SelfList<Apple> appleList = new SelfList<>();

        appleList.add(new Apple(1, "青色"));
        appleList.add(new Apple(2, "橙色"));
        appleList.add(new Apple(3, "红色"));
        appleList.add(new Apple(4, "绿色"));
        appleList.add(new Apple(5, "绿色"));
        appleList.add(new Apple(6, "紫色"));

        SelfList<Integer> greenAppleWightList = appleList.selfStream()
                .filter(item -> "绿色".equals(item.getColor()))
                .map(Apple::getWeight)
                .collect(SelfCollectors.toList());
        System.out.println(greenAppleWightList);

二、涉及到的泛型

从后向前看

1，SelfCollectors.toList()

public final class SelfCollectors {

    public static <T> SelfCollector<T, ?> toList() {
        return new SelfCollectorImpl<>((Supplier<List<T>>) SelfList::new, List::add);
    }

    static class SelfCollectorImpl<T, A> implements SelfCollector<T, A> {
        private final Supplier<A> supplier;
        private final BiConsumer<A, T> accumulator;

        SelfCollectorImpl(Supplier<A> supplier, BiConsumer<A, T> accumulator) {
            this.supplier = supplier;
            this.accumulator = accumulator;
        }

        @Override
        public BiConsumer<A, T> accumulator() {
            return accumulator;
        }

        @Override
        public Supplier<A> supplier() {
            return supplier;
        }
    }
}

假设SelfCollectorImpl已经定义好了，toList方法你会怎么写？

    public static <T> SelfCollector<T, ?> toList() {
        return new SelfCollectorImpl<T, SelfList<T>>(
                // 参数1：Supplier类型
                new Supplier<SelfList<T>>() {
                    @Override
                    public SelfList<T> get() {
                        return new SelfList<T>();
                    }
                },

                // 参数2：BiConsumer类型
                new BiConsumer<SelfList<T>, T>() {
                    @Override
                    public void accept(SelfList<T> list, T t) {
                        list.add(t);
                    }
                }
        );
    }

然后代码开发工具提示可以进行简化；

简化1，首先，由于传入的两个new 参数已经确定了SelfCollectorImpl类的泛型，如下图

所以，可以简化为：

    public static <T> SelfCollector<T, ?> toList() {
        return new SelfCollectorImpl<>(
                // 参数1：Supplier类型
                new Supplier<SelfList<T>>() {
                    @Override
                    public SelfList<T> get() {
                        return new SelfList<T>();
                    }
                },

                // 参数2：BiConsumer类型
                new BiConsumer<SelfList<T>, T>() {
                    @Override
                    public void accept(SelfList<T> list, T t) {
                        list.add(t);
                    }
                }
        );
    }

简化2，简化为lambda表达式：

    public static <T> SelfCollector<T, ?> toList() {
        return new SelfCollectorImpl<>(
                // 参数1：Supplier类型
                () -> new SelfList<T>(),

                // 参数2：BiConsumer类型
                (list, t) -> list.add(t)
        );
    }

简化3，Replace lambda with method reference:

    public static <T> SelfCollector<T, ?> toList() {
        return new SelfCollectorImpl<>(
                // 参数1：Supplier类型
                (Supplier<SelfList<T>>) SelfList::new,

                // 参数2：BiConsumer类型
                ArrayList::add
        );
    }

以上是通过Supplier先指定了SelfCollectorImpl的泛型A，A确定了，通过BiConsumer的定义，T也就确定了，如下图：

也可以改写成先通过BiConsumer来指定泛型：

    public static <T> SelfCollector<T, ?> toList() {
        return new SelfCollectorImpl<>(
                // 参数1：Supplier类型
                SelfList::new,

                // 参数2：BiConsumer类型
                (BiConsumer<SelfList<T>, T>) SelfList::add
        );
    }