使用带有 lambda 的 JDK8 压缩流(java.util.stream.Streams.zip) [英] Zipping streams using JDK8 with lambda (java.util.stream.Streams.zip)

问题描述

在带有 lambda b93 的 JDK 8 中有一个类 b93 中的 java.util.stream.Streams.zip 可用于压缩流(这在教程 探索 Java8 Lambdas.Dhananjay Nene 的第 1 部分).这个功能:

In JDK 8 with lambda b93 there was a class java.util.stream.Streams.zip in b93 which could be used to zip streams (this is illustrated in the tutorial Exploring Java8 Lambdas. Part 1 by Dhananjay Nene). This function :

创建一个惰性和顺序组合流，其元素是组合两个流的元素的结果.

Creates a lazy and sequential combined Stream whose elements are the result of combining the elements of two streams.

但是在 b98 中这已经消失了.事实上，Streams 类甚至无法在 b98 中的 java.util.stream.

However in b98 this has disappeared. Infact the Streams class is not even accessible in java.util.stream in b98.

此功能是否已移动，如果已移动，我该如何使用 b98 简洁地压缩流?

我想到的应用是在沉的这个java实现中，在这里我替换了

The application I have in mind is in this java implementation of Shen, where I replaced the zip functionality in the

• 静态boolean every(Collection c1, Collection c2, BiPredicate pred)
• 静态T find(Collection c1, Collection c2, BiPredicate pred)

具有相当冗长代码的函数(不使用 b98 的功能).

functions with rather verbose code (which doesn't use functionality from b98).

推荐答案

我也需要这个，所以我只是从 b93 中获取源代码并将它放在一个util"类中.我不得不稍微修改它以使用当前的 API.

I needed this as well so I just took the source code from b93 and put it in a "util" class. I had to modify it slightly to work with the current API.

这里是工作代码供参考(风险自负...):

For reference here's the working code (take it at your own risk...):

public static<A, B, C> Stream<C> zip(Stream<? extends A> a,
                                     Stream<? extends B> b,
                                     BiFunction<? super A, ? super B, ? extends C> zipper) {
    Objects.requireNonNull(zipper);
    Spliterator<? extends A> aSpliterator = Objects.requireNonNull(a).spliterator();
    Spliterator<? extends B> bSpliterator = Objects.requireNonNull(b).spliterator();

    // Zipping looses DISTINCT and SORTED characteristics
    int characteristics = aSpliterator.characteristics() & bSpliterator.characteristics() &
            ~(Spliterator.DISTINCT | Spliterator.SORTED);

    long zipSize = ((characteristics & Spliterator.SIZED) != 0)
            ? Math.min(aSpliterator.getExactSizeIfKnown(), bSpliterator.getExactSizeIfKnown())
            : -1;

    Iterator<A> aIterator = Spliterators.iterator(aSpliterator);
    Iterator<B> bIterator = Spliterators.iterator(bSpliterator);
    Iterator<C> cIterator = new Iterator<C>() {
        @Override
        public boolean hasNext() {
            return aIterator.hasNext() && bIterator.hasNext();
        }

        @Override
        public C next() {
            return zipper.apply(aIterator.next(), bIterator.next());
        }
    };

    Spliterator<C> split = Spliterators.spliterator(cIterator, zipSize, characteristics);
    return (a.isParallel() || b.isParallel())
           ? StreamSupport.stream(split, true)
           : StreamSupport.stream(split, false);
}

这篇关于使用带有 lambda 的 JDK8 压缩流(java.util.stream.Streams.zip)的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！