ストリームから連続するペアを収集する

のようなストリームを考えると{ 0, 1, 2, 3, 4 }、

どのようにして最もエレガントにそれを与えられた形式に変換できますか？

{ new Pair(0, 1), new Pair(1, 2), new Pair(2, 3), new Pair(3, 4) }

（もちろん、私はクラスPairを定義したと仮定します）？

編集：これは、厳密にはintやプリミティブストリームに関するものではありません。答えは、あらゆるタイプのストリームに対して一般的である必要があります。

標準ストリームを拡張するMy StreamExライブラリは、pairMapすべてのストリームタイプのメソッドを提供します。プリミティブストリームの場合、ストリームタイプは変更されませんが、いくつかの計算に使用できます。最も一般的な使用法は、差異の計算です。

int[] pairwiseDiffs = IntStreamEx.of(input).pairMap((a, b) -> (b-a)).toArray();

オブジェクトストリームの場合、他のオブジェクトタイプを作成できます。私のライブラリは、ユーザーに表示されるような新しいデータ構造を提供していませんPair（これはライブラリの概念の一部です）。ただし、独自のPairクラスがあり、それを使用したい場合は、以下を実行できます。

Stream<Pair> pairs = IntStreamEx.of(input).boxed().pairMap(Pair::new);

または、すでにいくつかある場合Stream：

Stream<Pair> pairs = StreamEx.of(stream).pairMap(Pair::new);

この機能は、カスタムスプリッターを使用して実装されます。オーバーヘッドがかなり低く、適切に並列化できます。もちろん、他の多くのソリューションのようなランダムアクセスリスト/アレイだけでなく、あらゆるストリームソースで機能します。多くのテストでそれは本当によく機能します。ここだ我々は（参照異なるアプローチを使用して、より大きな値を前のすべての入力値を見つけるJMHベンチマークこの質問は）。

Java 8ストリームライブラリは主に、並列処理のためにストリームを小さなチャンクに分割することを目的としているため、ステートフルパイプラインステージは非常に制限されており、現在のストリーム要素のインデックスの取得や隣接するストリーム要素へのアクセスなどの処理はサポートされていません。

もちろん、これらの問題を解決する一般的な方法は、いくつかの制限がありますが、インデックスでストリームを駆動し、要素を取得できるArrayListなどのランダムアクセスデータ構造で値を処理することに依存しています。値がにある場合、arrayList次のようなことを実行して、要求に応じてペアを生成できます。

    IntStream.range(1, arrayList.size())
             .mapToObj(i -> new Pair(arrayList.get(i-1), arrayList.get(i)))
             .forEach(System.out::println);

もちろん、入力が無限ストリームであってはならないという制限があります。ただし、このパイプラインは並行して実行できます。

これはエレガントではなく、ハックなソリューションですが、無限のストリームで機能します

Stream<Pair> pairStream = Stream.iterate(0, (i) -> i + 1).map( // natural numbers
    new Function<Integer, Pair>() {
        Integer previous;

        @Override
        public Pair apply(Integer integer) {
            Pair pair = null;
            if (previous != null) pair = new Pair(previous, integer);
            previous = integer;
            return pair;
        }
    }).skip(1); // drop first null

これで、ストリームを必要な長さに制限できます

pairStream.limit(1_000_000).forEach(i -> System.out.println(i));

PS私はclojureのようなより良い解決策があることを望みます(partition 2 1 stream)

私は、元のスプリッターからすべてのn要素Tを取得して生成するスプリッターラッパーを実装しましたList<T>。

public class ConsecutiveSpliterator<T> implements Spliterator<List<T>> {

    private final Spliterator<T> wrappedSpliterator;

    private final int n;

    private final Deque<T> deque;

    private final Consumer<T> dequeConsumer;

    public ConsecutiveSpliterator(Spliterator<T> wrappedSpliterator, int n) {
        this.wrappedSpliterator = wrappedSpliterator;
        this.n = n;
        this.deque = new ArrayDeque<>();
        this.dequeConsumer = deque::addLast;
    }

    @Override
    public boolean tryAdvance(Consumer<? super List<T>> action) {
        deque.pollFirst();
        fillDeque();
        if (deque.size() == n) {
            List<T> list = new ArrayList<>(deque);
            action.accept(list);
            return true;
        } else {
            return false;
        }
    }

    private void fillDeque() {
        while (deque.size() < n && wrappedSpliterator.tryAdvance(dequeConsumer))
            ;
    }

    @Override
    public Spliterator<List<T>> trySplit() {
        return null;
    }

    @Override
    public long estimateSize() {
        return wrappedSpliterator.estimateSize();
    }

    @Override
    public int characteristics() {
        return wrappedSpliterator.characteristics();
    }
}

次のメソッドを使用して、連続ストリームを作成できます。

public <E> Stream<List<E>> consecutiveStream(Stream<E> stream, int n) {
    Spliterator<E> spliterator = stream.spliterator();
    Spliterator<List<E>> wrapper = new ConsecutiveSpliterator<>(spliterator, n);
    return StreamSupport.stream(wrapper, false);
}

使用例：

consecutiveStream(Stream.of(0, 1, 2, 3, 4, 5), 2)
    .map(list -> new Pair(list.get(0), list.get(1)))
    .forEach(System.out::println);

Stream.reduce（）メソッドを使用してこれを行うことができます（このテクニックを使用した他の回答は見たことがありません）。

public static <T> List<Pair<T, T>> consecutive(List<T> list) {
    List<Pair<T, T>> pairs = new LinkedList<>();
    list.stream().reduce((a, b) -> {
        pairs.add(new Pair<>(a, b));
        return b;
    });
    return pairs;
}

これは、slidingオペレーターを使用して、cyclops-react（このライブラリーに寄稿）で行うことができます。

  LazyFutureStream.of( 0, 1, 2, 3, 4 )
                  .sliding(2)
                  .map(Pair::new);

または

   ReactiveSeq.of( 0, 1, 2, 3, 4 )
                  .sliding(2)
                  .map(Pair::new);

Pairコンストラクターが2つの要素を持つコレクションを受け入れることができると仮定します。

4でグループ化し、2でインクリメントする場合もサポートされます。

     ReactiveSeq.rangeLong( 0L,Long.MAX_VALUE)
                .sliding(4,2)
                .forEach(System.out::println);

java.util.stream.Streamのスライディングビューを作成するための同等の静的メソッドも、cyclops-streams StreamUtilsクラスで提供されます。

       StreamUtils.sliding(Stream.of(1,2,3,4),2)
                  .map(Pair::new);

注：-シングルスレッド操作の場合、ReactiveSeqがより適切です。LazyFutureStreamはReactiveSeqを拡張しますが、主に同時/並列使用向けです（先物ストリームです）。

LazyFutureStreamは、ReactiveSeqを拡張します。これは、素晴らしいjOOλ（java.util.stream.Streamを拡張）からSeqを拡張します。そのため、Lukasのプレゼントのソリューションは、どちらのStreamタイプでも機能します。興味のある人にとって、ウィンドウ/スライディングオペレーターの主な違いは、明らかな相対的なパワー/複雑さのトレードオフであり、無限ストリームでの使用に適しています（スライディングはストリームを消費しませんが、フロー中にバッファーを消費します）。

プロトンパックライブラリは、ウィンドウfunctionnalityを提供します。PairクラスとStreamを指定すると、次のように実行できます。

Stream<Integer> st = Stream.iterate(0 , x -> x + 1);
Stream<Pair<Integer, Integer>> pairs = StreamUtils.windowed(st, 2, 1)
                                                  .map(l -> new Pair<>(l.get(0), l.get(1)))
                                                  .moreStreamOps(...);

これで、pairsストリームには次が含まれます。

(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, ...) and so on

連続するペアを見つける

サードパーティのライブラリを使用して並列処理が不要な場合、jOOλは次のようなSQLスタイルのウィンドウ関数を提供します

System.out.println(
Seq.of(0, 1, 2, 3, 4)
   .window()
   .filter(w -> w.lead().isPresent())
   .map(w -> tuple(w.value(), w.lead().get())) // alternatively, use your new Pair() class
   .toList()
);

降伏

[(0, 1), (1, 2), (2, 3), (3, 4)]

このlead()関数は、ウィンドウからトラバーサル順序で次の値にアクセスします。

連続するトリプル/四重/ nタプルを見つける

コメントの質問は、より一般的な解決策を求めていました。ペアではなく、nタプル（またはおそらくリスト）を収集する必要があります。したがって、ここに代替アプローチがあります：

int n = 3;

System.out.println(
Seq.of(0, 1, 2, 3, 4)
   .window(0, n - 1)
   .filter(w -> w.count() == n)
   .map(w -> w.window().toList())
   .toList()
);

リストのリストを生成する

[[0, 1, 2], [1, 2, 3], [2, 3, 4]]

なしではfilter(w -> w.count() == n)、結果は

[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4], [4]]

免責事項：私はjOOλの背後にある会社で働いています

Streams.zip(..)依存している人のために、グアバで利用可能です。

例：

Streams.zip(list.stream(),
            list.stream().skip(1),
            (a, b) -> System.out.printf("%s %s\n", a, b));

RxJava（非常に強力なリアクティブ拡張ライブラリ）を使用できます

IntStream intStream  = IntStream.iterate(1, n -> n + 1);

Observable<List<Integer>> pairObservable = Observable.from(intStream::iterator).buffer(2,1);

pairObservable.take(10).forEach(b -> {
            b.forEach(n -> System.out.println(n));
            System.out.println();
        });

バッファ オペレータが発するが、これらのアイテムのコレクションを緩衝することを観察可能に観測その発するアイテムを変換します..

操作は、ストリームが解決することを意図しているものではないので、実際には、本質的にステートフルである-に「ステートレス行動」のセクションを参照してくださいjavadocは：

最善のアプローチは、操作を完全にストリーミングするステートフルな動作パラメーターを回避することです

ここでの1つの解決策は、外部カウンターを通じてストリームに状態を​​導入することですが、これはシーケンシャルストリームでのみ機能します。

public static void main(String[] args) {
    Stream<String> strings = Stream.of("a", "b", "c", "c");
    AtomicReference<String> previous = new AtomicReference<>();
    List<Pair> collect = strings.map(n -> {
                            String p = previous.getAndSet(n);
                            return p == null ? null : new Pair(p, n);
                        })
                        .filter(p -> p != null)
                        .collect(toList());
    System.out.println(collect);
}


static class Pair<T> {
    private T left, right;
    Pair(T left, T right) { this.left = left; this.right = right; }
    @Override public String toString() { return "{" + left + "," + right + '}'; }
}

あなたの場合、最後に渡されたintを追跡するカスタムIntFunctionを記述し、それを使用して元のIntStreamをマップします。

import java.util.function.IntFunction;
import java.util.stream.IntStream;

public class PairFunction implements IntFunction<PairFunction.Pair> {

  public static class Pair {

    private final int first;
    private final int second;

    public Pair(int first, int second) {
      this.first = first;
      this.second = second;
    }

    @Override
    public String toString() {
      return "[" + first + "|" + second + "]";
    }
  }

  private int last;
  private boolean first = true;

  @Override
  public Pair apply(int value) {
    Pair pair = !first ? new Pair(last, value) : null;
    last = value;
    first = false;
    return pair;
  }

  public static void main(String[] args) {

    IntStream intStream = IntStream.of(0, 1, 2, 3, 4);
    final PairFunction pairFunction = new PairFunction();
    intStream.mapToObj(pairFunction)
        .filter(p -> p != null) // filter out the null
        .forEach(System.out::println); // display each Pair

  }

}

時系列の時間（x値）の連続する差を計算するには、streamのcollect(...)方法を使用します。

final List< Long > intervals = timeSeries.data().stream()
                    .map( TimeSeries.Datum::x )
                    .collect( DifferenceCollector::new, DifferenceCollector::accept, DifferenceCollector::combine )
                    .intervals();

DifferenceCollectorは次のようになります。

public class DifferenceCollector implements LongConsumer
{
    private final List< Long > intervals = new ArrayList<>();
    private Long lastTime;

    @Override
    public void accept( final long time )
    {
        if( Objects.isNull( lastTime ) )
        {
            lastTime = time;
        }
        else
        {
            intervals.add( time - lastTime );
            lastTime = time;
        }
    }

    public void combine( final DifferenceCollector other )
    {
        intervals.addAll( other.intervals );
        lastTime = other.lastTime;
    }

    public List< Long > intervals()
    {
        return intervals;
    }
}

おそらく、必要に応じてこれを変更できます。

ようやく、Stream.reduceをだまして値のペアを適切に処理できる方法を見つけました。この機能を必要とするユースケースは多数ありますが、JDK 8 には自然には現れません。

public static int ArithGeo(int[] arr) {
    //Geometric
    List<Integer> diffList = new ArrayList<>();
    List<Integer> divList = new ArrayList<>();
    Arrays.stream(arr).reduce((left, right) -> {
        diffList.add(right-left);
        divList.add(right/left);
        return right;
    });
    //Arithmetic
    if(diffList.stream().distinct().count() == 1) {
        return 1;
    }
    //Geometric
    if(divList.stream().distinct().count() == 1) {
        return 2;
    }
    return -1;
}

私が使用するトリックは、復帰権です。ステートメント。

エレガントなソリューションはzipを使用することです。何かのようなもの：

List<Integer> input = Arrays.asList(0, 1, 2, 3, 4);
Stream<Pair> pairStream = Streams.zip(input.stream(),
                                      input.stream().substream(1),
                                      (a, b) -> new Pair(a, b)
);

これはかなり簡潔でエレガントですが、入力としてリストを使用します。無限ストリームソースはこの方法では処理できません。

もう1つの（かなり厄介な）問題は、zipとStreamsクラス全体が最近APIから削除されていることです。上記のコードは、b95以前のリリースでのみ機能します。したがって、最新のJDKでは、エレガントなFPスタイルのソリューションは存在しないと思います。現時点では、何らかの方法でzipがAPIに再導入されることを期待できます。

これは興味深い問題です。私のハイブリッドの試みは何か良いものですか？

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, 3);
    Iterator<Integer> first = list.iterator();
    first.next();
    if (first.hasNext())
        list.stream()
        .skip(1)
        .map(v -> new Pair(first.next(), v))
        .forEach(System.out::println);
}

並列処理には向いていないため、失格となる可能性があります。

他の人が観察したように、問題の性質上、ある程度のステートフル性が必要です。

私は同様の問題に直面しました。この問題では、本質的にOracle SQL関数LEADが必要でした。それを実装する私の試みは以下です。

/**
 * Stream that pairs each element in the stream with the next subsequent element.
 * The final pair will have only the first item, the second will be null.
 */
<T> Spliterator<Pair<T>> lead(final Stream<T> stream)
{
    final Iterator<T> input = stream.sequential().iterator();

    final Iterable<Pair<T>> iterable = () ->
    {
        return new Iterator<Pair<T>>()
        {
            Optional<T> current = getOptionalNext(input);

            @Override
            public boolean hasNext()
            {
                return current.isPresent();
            }

            @Override
            public Pair<T> next()
            {
                Optional<T> next = getOptionalNext(input);
                final Pair<T> pair = next.isPresent()
                    ? new Pair(current.get(), next.get())
                    : new Pair(current.get(), null);
                current = next;

                return pair;
            }
        };
    };

    return iterable.spliterator();
}

private <T> Optional<T> getOptionalNext(final Iterator<T> iterator)
{
    return iterator.hasNext()
        ? Optional.of(iterator.next())
        : Optional.empty();
}

これを実現するには、境界キューを使用して、ストリームを流れる要素を格納します（これは、ここで詳細に説明したアイデアに基づいています）。 ストリーム内の次の要素を取得することは可能ですか？）

以下の例では、最初に、ストリームを通過する要素を格納するBoundedQueueクラスのインスタンスを定義します（LinkedListを拡張したくない場合は、上記のリンクを参照して、代替のより一般的な方法を確認してください）。その後、2つの後続の要素を組み合わせてペアのインスタンスにします。

public class TwoSubsequentElems {
  public static void main(String[] args) {
    List<Integer> input = new ArrayList<Integer>(asList(0, 1, 2, 3, 4));

    class BoundedQueue<T> extends LinkedList<T> {
      public BoundedQueue<T> save(T curElem) {
        if (size() == 2) { // we need to know only two subsequent elements
          pollLast(); // remove last to keep only requested number of elements
        }

        offerFirst(curElem);

        return this;
      }

      public T getPrevious() {
        return (size() < 2) ? null : getLast();
      }

      public T getCurrent() {
        return (size() == 0) ? null : getFirst();
      }
    }

    BoundedQueue<Integer> streamHistory = new BoundedQueue<Integer>();

    final List<Pair<Integer>> answer = input.stream()
      .map(i -> streamHistory.save(i))
      .filter(e -> e.getPrevious() != null)
      .map(e -> new Pair<Integer>(e.getPrevious(), e.getCurrent()))
      .collect(Collectors.toList());

    answer.forEach(System.out::println);
  }
}

@aepurnietに同意しますが、代わりにマップするにはmapToObjを使用する必要があります

range(0, 100).mapToObj((i) -> new Pair(i, i+1)).forEach(System.out::println);

ストリームのfor0から実行されるループを実行するlength-1

for(int i = 0 ; i < stream.length-1 ; i++)
{
    Pair pair = new Pair(stream[i], stream[i+1]);
    // then add your pair to an array
}