为什么.flatMap()是如此低效(非懒惰)？

Question

关于深化认识Java流spliterators的第一个问题后,这里为什么执行:约溪流另一个微妙的问题.flatMap()在Java中是如此低效(非懒惰)？

通常,流应该尽可能地保持懒惰,但.flatMap()方法不是.

例如:

stream.flatMap(this::getStreamWith10HeavyComputationElems).firstFirst() 在返回第一个繁重的计算结果之前,将消耗10个元素(10次重计算).

stream.flatMap(this::getStreamWith10HeavyComputationElems).limit(11).count() 在返回11之前将消耗20个元素(2x10重计算).

该问题是为什么Java使用非懒实施？

    @Test
    void flatMap_native() throws Exception {
        AtomicInteger count = new AtomicInteger();
        Stream<Long> stream = LongStream.range(0, 5).boxed()
                .flatMap(num -> LongStream.range(0, 10).boxed()
                                    .peek(x -> count.incrementAndGet()))
                .limit(11);

        assertThat(stream).hasSize(11);
        assertThat(count).hasValue(20); //!why? - should be 11!
    }

作为解决方法,我创建了自己的flatMap实现,但与本机调用相比,它缺乏流畅性:flatMap(stream, mapper)vs native stream.flatMap(mapper).

public static <T, R> Stream<R> flatMap(Stream<? extends T> stream, Function<? super T, ? extends Stream<? extends R>> mapper) {
    // Outside the class to be able to close it, starts with stream.empty
    AtomicReference<Stream<? extends R>> flatMapStreamRef = new AtomicReference<>(Stream.empty());

    // Defining a better spliterator than the native flatMap one.
    class FlatMapSpliterator implements Spliterator<R> {
        private final AtomicReference<T> item = new AtomicReference<>();
        private final Spliterator<? extends T> spliterator;
        private Stream<? extends R> flatMapStream = flatMapStreamRef.get();
        private Spliterator<? extends R> flatMapSpliterator = flatMapStream.spliterator();

        private FlatMapSpliterator(Spliterator<? extends T> spliterator) {
            this.spliterator = spliterator;
        }

        @Override
        public boolean tryAdvance(Consumer<? super R> action) {
            while(true) {
                if (flatMapSpliterator.tryAdvance(action)) {
                    return true;
                }
                if (!spliterator.tryAdvance(item::set)) {
                    return false; // nothing more to process
                }
                Stream<? extends R> stream = mapper.apply(item.get());
                if(stream != null) {
                    flatMapStream.close();
                    flatMapStream = stream;
                    flatMapStreamRef.set(stream);
                    flatMapSpliterator = flatMapStream.spliterator();
                }
            }
        }

        @Override
        @SuppressWarnings("unchecked")
        public Spliterator<R> trySplit() {
            Spliterator<? extends R> subFlatMapSpliterator = flatMapSpliterator.trySplit();
            if(subFlatMapSpliterator != null) {
                return (Spliterator<R>) subFlatMapSpliterator;
            }

            Spliterator<? extends T> subSpliterator = spliterator.trySplit();
            if(subSpliterator == null) {
                return null;
            }

            return new FlatMapSpliterator(subSpliterator);
        }

        @Override
        public long estimateSize() {
            // If both estimate size are Long.MAX_VALUE then math overflow will happen
            long estimateSize = spliterator.estimateSize() + flatMapSpliterator.estimateSize();
            return estimateSize < 0 ? Long.MAX_VALUE : estimateSize;
        }

        @Override
        public int characteristics() {
            // Maintain only ORDERED (used by native flatMap)
            return spliterator.characteristics() & ORDERED;
        }
    }

    return StreamSupport.stream(new FlatMapSpliterator(stream.spliterator()), stream.isParallel())
            .onClose(stream::close)
            .onClose(flatMapStreamRef.get()::close);
}