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

问题描述

在带lambda b93的JDK 8中，有一个类 java.util在b93中的.stream.Streams.zip 这可以用于压缩流（这在教程中进行了说明探索Java8 Lambdas。第1部分Dhananjay Nene ）。此函数：

创建一个惰性和顺序组合的Stream，其元素是组合两个流的元素的
结果。 / p>

然而在b98中这个消失了。事实上， Streams 类甚至在 b98 中的java.util.stream。

是否已移动此功能，如果是的话，我如何使用b98精简地压缩数据流？ $ b

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

• static< T> boolean every（Collection c1，Collection c2，BiPredicate pred）

• static< T> T find（Collection T c1，Collection T c2，BiPredicate T，T pred））/ b
  
  
  

  功能相当详细的代码（它不使用b98的功能）。 我还需要这个我只是从b93获取源代码并将其放在util类中。我不得不稍微修改它以适应当前的API。

  
  
  

  这里是工作代码的参考（承担您的风险......）：
  
  pre > public static< A，B，C>流< c取代; zip（Stream <？extends A> a，
Stream <？extends B> b，
BiFunction <？super A，？super B>？extends C> zipper）{
Objects.requireNonNull （拉链）;
Spliterator <？延伸A> aSpliterator = Objects.requireNonNull（a）.spliterator（）;
Spliterator <？扩展B> bSpliterator = Objects.requireNonNull（b）.spliterator（）;

//压缩失去DISTINCT和SORTED特性
int特性= aSpliterator.characteristics（）& bSpliterator.characteristics（）&
〜（Spliterator.DISTINCT | Spliterator.SORTED）;

long zipSize =（（characteristics& Spliterator.SIZED）！= 0）
？ Math.min（aSpliterator.getExactSizeIfKnown（），bSpliterator.getExactSizeIfKnown（））
：-1;

迭代器< A> aIterator = Spliterators.iterator（aSpliterator）;
迭代器< B> bIterator = Spliterators.iterator（bSpliterator）;
迭代器< 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，features）;
return（a.isParallel（）|| b.isParallel（））
？ StreamSupport.stream（split，true）
：StreamSupport.stream（split，false）;
}


  
  

  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.

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

  Has this functionality been moved, and if so how do I zip streams concisely using b98?

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

  • static <T> boolean every(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)
  • static <T> T find(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred)

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

  解决方案

  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屋！