JDK8とラムダ(java.util.stream.Streams.zip)を使用したスト​​リームの圧縮


149

ラムダb93を使用するJDK 8では、ストリーム圧縮するために使用できるクラスjava.util.stream.Streams.zipがb93にありました(これは、チュートリアル「Java8ラムダを探索する」で説明されています。DhananjayNeneによるパート1)。この機能:

2つのストリームの要素を組み合わせた結果を要素とする、レイジーで順次結合されたStreamを作成します。

ただし、b98ではこれがなくなりました。実際には、Streamsクラスはb98のjava.util.streamでさえアクセスできません。

この機能は移動されましたか。移動されている場合、b98を使用してストリームを簡潔に圧縮するにはどうすればよいですか?

私が考えているアプリケーションは、このShenのJava実装にあります。

  • 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)

(b98の機能を使用しない)かなり冗長なコードで機能します。


3
ああちょうど完全に除去されているようだということが分かった:mail.openjdk.java.net/pipermail/lambda-libs-spec-observers/...
artella

「Java8ラムダを探索する。パート1」-この記事の新しいリンクはblog.dhananjaynene.com/2013/02/exploring-java8-lambdas-part-1
Aleksei Egorov

回答:


77

これも必要だったので、b93からソースコードを取り出して「util」クラスに入れました。現在のAPIで動作するように少し変更する必要がありました。

参考までに、ここに作業コードを示します(ご自身の責任で行ってください...):

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);
}

1
どちらか一方のストリームが両方ではなくであるSIZED場合、結果のストリームになるべきではありませんか?SIZED
Didier L

5
そうは思いません。SIZEDこの実装が機能するには、両方のストリームが必要です。実際には、zipの定義方法によって異なります。たとえば、サイズの異なる2つのストリームを圧縮できる必要がありますか?その結果、ストリームはどのようになりますか?これが、この関数が実際にAPIから省略された理由だと思います。これを行うには多くの方法があり、どの動作が「正しい」動作であるかをユーザーが決定する必要があります。長いストリームから要素を破棄するか、短いリストにパディングしますか?もしそうなら、どのような値で?
siki

私が何かを逃していない限り、キャスト(例:)は必要ありませんSpliterator<A>
jub0bs

Java 8 b93ソースコードがホストされているWebサイトはありますか?見つけられません。
Starwarswii 2017

42

zipは、protonpackライブラリによって提供される関数の1つです。

Stream<String> streamA = Stream.of("A", "B", "C");
Stream<String> streamB  = Stream.of("Apple", "Banana", "Carrot", "Doughnut");

List<String> zipped = StreamUtils.zip(streamA,
                                      streamB,
                                      (a, b) -> a + " is for " + b)
                                 .collect(Collectors.toList());

assertThat(zipped,
           contains("A is for Apple", "B is for Banana", "C is for Carrot"));


34

プロジェクトにGuavaがある場合、Streams.zipメソッドを使用できます(Guava 21で追加されました)。

各要素がstreamAとstreamBのそれぞれの対応する要素を関数に渡した結果であるストリームを返します。結果のストリームは、2つの入力ストリームのうち短い方だけになります。1つのストリームが長い場合、その余分な要素は無視されます。結果のストリームは効率的に分割できません。これは並列パフォーマンスに悪影響を与える可能性があります。

 public class Streams {
     ...

     public static <A, B, R> Stream<R> zip(Stream<A> streamA,
             Stream<B> streamB, BiFunction<? super A, ? super B, R> function) {
         ...
     }
 }

26

JDK8とラムダ(gist)を使用して2つのストリームを圧縮する。

public static <A, B, C> Stream<C> zip(Stream<A> streamA, Stream<B> streamB, BiFunction<A, B, C> zipper) {
    final Iterator<A> iteratorA = streamA.iterator();
    final Iterator<B> iteratorB = streamB.iterator();
    final Iterator<C> iteratorC = new Iterator<C>() {
        @Override
        public boolean hasNext() {
            return iteratorA.hasNext() && iteratorB.hasNext();
        }

        @Override
        public C next() {
            return zipper.apply(iteratorA.next(), iteratorB.next());
        }
    };
    final boolean parallel = streamA.isParallel() || streamB.isParallel();
    return iteratorToFiniteStream(iteratorC, parallel);
}

public static <T> Stream<T> iteratorToFiniteStream(Iterator<T> iterator, boolean parallel) {
    final Iterable<T> iterable = () -> iterator;
    return StreamSupport.stream(iterable.spliterator(), parallel);
}

2
素敵なソリューションと(比較的)コンパクト!あなたが置くことが必要import java.util.function.*;import java.util.stream.*;ファイルの先頭に。
sffc

これはストリームの最終操作であることに注意してください。これは、無限のストリームの場合、このメソッドが機能しないことを意味します
smac89

2
あまり役に立たないラッパー:ここ() -> iteratorとここでも:iterable.spliterator()Spliteratorではなく、直接実装しないのはなぜIteratorですか?@Doradus解答チェックstackoverflow.com/a/46230233/1140754
ミゲル・ガンボア

20

インデックス付けされたもの(リスト)以外のコレクションでの圧縮の使用は考えられず、単純化の大ファンなので、これが私の解決策になります。

<A,B,C>  Stream<C> zipped(List<A> lista, List<B> listb, BiFunction<A,B,C> zipper){
     int shortestLength = Math.min(lista.size(),listb.size());
     return IntStream.range(0,shortestLength).mapToObj( i -> {
          return zipper.apply(lista.get(i), listb.get(i));
     });        
}

1
あるmapToObjectべきだと思いますmapToObj
seanf

リストがそうでない場合RandomAccess(リンクされたリストなど)、これは非常に遅くなります
avmohan

間違いなく。しかし、ほとんどのJava開発者は、LinkedListのインデックスアクセス操作のパフォーマンスが低いことをよく知っています。
ラファエル

11

あなたが言及したクラスのメソッドはStream、デフォルトのメソッドに代わり、インターフェース自体に移動されました。しかし、zipメソッドは削除されたようです。さまざまなサイズのストリームのデフォルトの動作が明確でないためかもしれません。ただし、目的の動作を実装するのは簡単です。

static <T> boolean every(
  Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred) {
    Iterator<T> it=c2.iterator();
    return c1.stream().allMatch(x->!it.hasNext()||pred.test(x, it.next()));
}
static <T> T find(Collection<T> c1, Collection<T> c2, BiPredicate<T, T> pred) {
    Iterator<T> it=c2.iterator();
    return c1.stream().filter(x->it.hasNext()&&pred.test(x, it.next()))
      .findFirst().orElse(null);
}

predicateフィルターに渡したのはステートフルではありませんか?これはメソッドコントラクトに違反し、特にストリームを並列処理する場合には機能しません。
Andreas

2
@Andreas:並列処理をサポートするソリューションはありません。私のメソッドはストリームを返さないので、ストリームが並行して実行されないようにします。同様に、受け入れられた回答のコードは、並列に変換できるストリームを返しますが、実際には並列には何も行いません。とはいえ、ステートフルな述語は推奨されていませんが、契約に違反していません。状態の更新がスレッドセーフであることを確認すると、並列コンテキストで使用されることもあります。状況によっては避けられないことがあります。たとえば、ストリームを個別に変換すること自体がステートフルな述語です。
Holger

2
@Andreas:これらの操作がJava APIから削除された理由はご想像のとおり…
Holger

8

私はこの実装を謙虚に提案します。結果のストリームは、2つの入力ストリームのうち短い方に切り捨てられます。

public static <L, R, T> Stream<T> zip(Stream<L> leftStream, Stream<R> rightStream, BiFunction<L, R, T> combiner) {
    Spliterator<L> lefts = leftStream.spliterator();
    Spliterator<R> rights = rightStream.spliterator();
    return StreamSupport.stream(new AbstractSpliterator<T>(Long.min(lefts.estimateSize(), rights.estimateSize()), lefts.characteristics() & rights.characteristics()) {
        @Override
        public boolean tryAdvance(Consumer<? super T> action) {
            return lefts.tryAdvance(left->rights.tryAdvance(right->action.accept(combiner.apply(left, right))));
        }
    }, leftStream.isParallel() || rightStream.isParallel());
}

私はあなたの提案が好きです。しかし、私は最後に完全に同意しません.., leftStream.isParallel() || rightStream.isParallel()AbstractSpliteratorデフォルトでは並列処理が制限されているため、効果がないと思います。だから最終的な結果は合格と同じになると思いますfalse
Miguel Gamboa

@MiguelGamboa-コメントありがとうございます。「デフォルトでの並列処理の制限」の意味がわかりません-一部のドキュメントへのリンクはありますか?
Doradus、

6

Lazy-Seqライブラリはzip機能を提供します。

https://github.com/nurkiewicz/LazySeq

このライブラリはscala.collection.immutable.Stream、不変で、スレッドセーフで、使いやすいレイジーシーケンスの実装を提供することを目的としており、無限である可能性があります。


5

最新のGuavaライブラリー(Streamsクラス用)を使用すると、実行できるはずです。

final Map<String, String> result = 
    Streams.zip(
        collection1.stream(), 
        collection2.stream(), 
        AbstractMap.SimpleEntry::new)
    .collect(Collectors.toMap(e -> e.getKey(), e  -> e.getValue()));

2

これでうまくいきますか?これは、圧縮するストリームに対して遅延評価する短い関数なので、無限ストリームを提供できます(圧縮するストリームのサイズをとる必要はありません)。

ストリームが有限の場合、ストリームの1つが要素を使い果たすとすぐに停止します。

import java.util.Objects;
import java.util.function.BiFunction;
import java.util.stream.Stream;

class StreamUtils {
    static <ARG1, ARG2, RESULT> Stream<RESULT> zip(
            Stream<ARG1> s1,
            Stream<ARG2> s2,
            BiFunction<ARG1, ARG2, RESULT> combiner) {
        final var i2 = s2.iterator();
        return s1.map(x1 -> i2.hasNext() ? combiner.apply(x1, i2.next()) : null)
                .takeWhile(Objects::nonNull);
    }
}

ここにいくつかの単体テストコードがあります(コード自体よりもはるかに長いです!)

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;

class StreamUtilsTest {
    @ParameterizedTest
    @MethodSource("shouldZipTestCases")
    <ARG1, ARG2, RESULT>
    void shouldZip(
            String testName,
            Stream<ARG1> s1,
            Stream<ARG2> s2,
            BiFunction<ARG1, ARG2, RESULT> combiner,
            Stream<RESULT> expected) {
        var actual = StreamUtils.zip(s1, s2, combiner);

        assertEquals(
                expected.collect(Collectors.toList()),
                actual.collect(Collectors.toList()),
                testName);
    }

    private static Stream<Arguments> shouldZipTestCases() {
        return Stream.of(
                Arguments.of(
                        "Two empty streams",
                        Stream.empty(),
                        Stream.empty(),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.empty()),
                Arguments.of(
                        "One singleton and one empty stream",
                        Stream.of(1),
                        Stream.empty(),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.empty()),
                Arguments.of(
                        "One empty and one singleton stream",
                        Stream.empty(),
                        Stream.of(1),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.empty()),
                Arguments.of(
                        "Two singleton streams",
                        Stream.of("blah"),
                        Stream.of(1),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.of(pair("blah", 1))),
                Arguments.of(
                        "One singleton, one multiple stream",
                        Stream.of("blob"),
                        Stream.of(2, 3),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.of(pair("blob", 2))),
                Arguments.of(
                        "One multiple, one singleton stream",
                        Stream.of("foo", "bar"),
                        Stream.of(4),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.of(pair("foo", 4))),
                Arguments.of(
                        "Two multiple streams",
                        Stream.of("nine", "eleven"),
                        Stream.of(10, 12),
                        (BiFunction<Object, Object, Object>) StreamUtilsTest::combine,
                        Stream.of(pair("nine", 10), pair("eleven", 12)))
        );
    }

    private static List<Object> pair(Object o1, Object o2) {
        return List.of(o1, o2);
    }

    static private <T1, T2> List<Object> combine(T1 o1, T2 o2) {
        return List.of(o1, o2);
    }

    @Test
    void shouldLazilyEvaluateInZip() {
        final var a = new AtomicInteger();
        final var b = new AtomicInteger();
        final var zipped = StreamUtils.zip(
                Stream.generate(a::incrementAndGet),
                Stream.generate(b::decrementAndGet),
                (xa, xb) -> xb + 3 * xa);

        assertEquals(0, a.get(), "Should not have evaluated a at start");
        assertEquals(0, b.get(), "Should not have evaluated b at start");

        final var takeTwo = zipped.limit(2);

        assertEquals(0, a.get(), "Should not have evaluated a at take");
        assertEquals(0, b.get(), "Should not have evaluated b at take");

        final var list = takeTwo.collect(Collectors.toList());

        assertEquals(2, a.get(), "Should have evaluated a after collect");
        assertEquals(-2, b.get(), "Should have evaluated b after collect");
        assertEquals(List.of(2, 4), list);
    }
}

takeWhile最後にドロップする必要があったのは、java8にはないようですが、zipされたストリームが同じサイズでないときに発生するnullを呼び出し先がフィルタリングできるため、問題ではありません。この答えは、構成されて理解できるので、一番の答えになるはずだと思います。ありがとうございます。
simbo1905

1
public class Tuple<S,T> {
    private final S object1;
    private final T object2;

    public Tuple(S object1, T object2) {
        this.object1 = object1;
        this.object2 = object2;
    }

    public S getObject1() {
        return object1;
    }

    public T getObject2() {
        return object2;
    }
}


public class StreamUtils {

    private StreamUtils() {
    }

    public static <T> Stream<Tuple<Integer,T>> zipWithIndex(Stream<T> stream) {
        Stream<Integer> integerStream = IntStream.range(0, Integer.MAX_VALUE).boxed();
        Iterator<Integer> integerIterator = integerStream.iterator();
        return stream.map(x -> new Tuple<>(integerIterator.next(), x));
    }
}

1

私が貢献しているAOLのcyclops-reactは、拡張Stream実装を介して、リアクティブストリームインターフェイスReactiveSeqも実装する、および標準のJavaストリームに静的メソッドを介して同じ機能の多くを提供するStreamUtilsを介して、圧縮機能を提供します。

 List<Tuple2<Integer,Integer>> list =  ReactiveSeq.of(1,2,3,4,5,6)
                                                  .zip(Stream.of(100,200,300,400));


  List<Tuple2<Integer,Integer>> list = StreamUtils.zip(Stream.of(1,2,3,4,5,6),
                                                  Stream.of(100,200,300,400));

また、より一般化されたApplicativeベースの圧縮を提供します。例えば

   ReactiveSeq.of("a","b","c")
              .ap3(this::concat)
              .ap(of("1","2","3"))
              .ap(of(".","?","!"))
              .toList();

   //List("a1.","b2?","c3!");

   private String concat(String a, String b, String c){
    return a+b+c;
   }

また、あるストリームのすべてのアイテムを別のストリームのすべてのアイテムとペアにする機能も

   ReactiveSeq.of("a","b","c")
              .forEach2(str->Stream.of(str+"!","2"), a->b->a+"_"+b);

   //ReactiveSeq("a_a!","a_2","b_b!","b_2","c_c!","c2")

0

誰かがこれをまだ必要としているならStreamEx.zipWithstreamexライブラリに関数があります:

StreamEx<String> givenNames = StreamEx.of("Leo", "Fyodor")
StreamEx<String> familyNames = StreamEx.of("Tolstoy", "Dostoevsky")
StreamEx<String> fullNames = givenNames.zipWith(familyNames, (gn, fn) -> gn + " " + fn);

fullNames.forEach(System.out::println);  // prints: "Leo Tolstoy\nFyodor Dostoevsky\n"

-1

これは素晴らしい。2つのストリームをMapに圧縮する必要がありました。1つのストリームがキーで、もう1つのストリームが値です。

Stream<String> streamA = Stream.of("A", "B", "C");
Stream<String> streamB  = Stream.of("Apple", "Banana", "Carrot", "Doughnut");    
final Stream<Map.Entry<String, String>> s = StreamUtils.zip(streamA,
                    streamB,
                    (a, b) -> {
                        final Map.Entry<String, String> entry = new AbstractMap.SimpleEntry<String, String>(a, b);
                        return entry;
                    });

System.out.println(s.collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue())));

出力:{A =アップル、B =バナナ、C =ニンジン}

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.