Kumpulkan pasangan yang berurutan dari aliran

Diberikan aliran seperti { 0, 1, 2, 3, 4 },

bagaimana cara paling elegan mengubahnya menjadi bentuk tertentu:

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

(dengan asumsi, tentu saja, saya telah mendefinisikan kelas Pair)?

Sunting: Ini bukan hanya tentang int atau aliran primitif. Jawabannya harus umum untuk aliran jenis apa pun.

Perpustakaan StreamEx saya yang memperluas aliran standar menyediakan pairMapmetode untuk semua jenis aliran. Untuk aliran primitif, ini tidak mengubah jenis aliran, tetapi dapat digunakan untuk membuat beberapa perhitungan. Penggunaan paling umum adalah untuk menghitung perbedaan:

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

Untuk aliran objek, Anda dapat membuat jenis objek lainnya. Perpustakaan saya tidak menyediakan struktur data baru yang terlihat oleh pengguna seperti Pair(itu adalah bagian dari konsep perpustakaan). Namun jika Anda memiliki Pairkelas Anda sendiri dan ingin menggunakannya, Anda dapat melakukan hal berikut:

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

Atau jika Anda sudah memiliki beberapa Stream:

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

Fungsionalitas ini diimplementasikan menggunakan pemisah khusus . Ini memiliki overhead yang cukup rendah dan dapat diparalelkan dengan baik. Tentu saja ini berfungsi dengan sumber aliran apa pun, bukan hanya daftar / larik akses acak seperti banyak solusi lainnya. Dalam banyak pengujian, alat ini bekerja dengan sangat baik. Berikut adalah patokan JMH di mana kita menemukan semua nilai input sebelum nilai yang lebih besar menggunakan pendekatan yang berbeda (lihat pertanyaan ini ).

Pustaka aliran Java 8 terutama ditujukan untuk memisahkan aliran menjadi potongan yang lebih kecil untuk pemrosesan paralel, sehingga tahapan pipeline stateful sangat terbatas, dan melakukan hal-hal seperti mendapatkan indeks elemen aliran saat ini dan mengakses elemen aliran yang berdekatan tidak didukung.

Cara khas untuk memecahkan masalah ini, dengan beberapa keterbatasan, tentu saja, adalah dengan mengarahkan aliran dengan indeks dan mengandalkan nilai yang diproses dalam beberapa struktur data akses-acak seperti ArrayList tempat elemen dapat diambil. Jika nilainya masuk arrayList, seseorang dapat menghasilkan pasangan seperti yang diminta dengan melakukan sesuatu seperti ini:

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

Tentu saja batasannya adalah input tidak bisa menjadi aliran yang tak terbatas. Pipeline ini bisa dijalankan secara paralel.

Ini tidak elegan, ini adalah solusi hackish, tetapi berfungsi untuk aliran tak terbatas

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

Sekarang Anda dapat membatasi streaming sesuai durasi yang Anda inginkan

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

PS Saya berharap ada solusi yang lebih baik, seperti clojure(partition 2 1 stream)

Saya telah menerapkan pembungkus spliterator yang mengambil setiap nelemen Tdari spliterator asli dan menghasilkan 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();
    }
}

Metode berikut dapat digunakan untuk membuat aliran berurutan:

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

Penggunaan sampel:

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

Anda dapat melakukan ini dengan metode Stream.reduce () (Saya belum melihat jawaban lain menggunakan teknik ini).

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

Anda dapat melakukan ini di cyclops-react (saya berkontribusi pada perpustakaan ini), menggunakan operator geser.

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

Atau

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

Dengan asumsi konstruktor Pair dapat menerima Koleksi dengan 2 elemen.

Jika Anda ingin mengelompokkan dengan 4, dan kenaikan 2 itu juga didukung.

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

Metode statis setara untuk membuat tampilan geser di atas java.util.stream.Stream juga disediakan di kelas StreamUtils cyclops-streams .

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

Catatan: - untuk operasi single-threaded, ReactiveSeq akan lebih sesuai. LazyFutureStream memperluas ReactiveSeq tetapi terutama ditujukan untuk penggunaan bersamaan / paralel (ini adalah Stream of Futures).

LazyFutureStream memperluas ReactiveSeq yang memperluas Seq dari jOOλ yang mengagumkan (yang memperluas java.util.stream.Stream), sehingga solusi yang diberikan Lukas juga akan berfungsi dengan salah satu jenis Stream. Bagi siapa pun yang tertarik, perbedaan utama antara operator jendela / geser adalah daya relatif / kompleksitas yang jelas trade off dan kesesuaian untuk digunakan dengan aliran tak terbatas (geser tidak menghabiskan aliran, tetapi menyangga saat mengalir).

The proton-pack perpustakaan menyediakan functionnality berjendela. Diberikan kelas Pair dan Stream, Anda dapat melakukannya seperti ini:

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(...);

Sekarang pairsaliran tersebut berisi:

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

Menemukan pasangan yang berurutan

Jika Anda ingin menggunakan pustaka pihak ketiga dan tidak membutuhkan paralelisme, maka jOOλ menawarkan fungsi jendela gaya SQL sebagai berikut

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

Menghasilkan

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

The lead()Fungsi mengakses nilai berikutnya dalam rangka traversal dari jendela.

Menemukan tripel / quadruples / n-tuple yang berurutan

Sebuah pertanyaan di komentar meminta solusi yang lebih umum, di mana tidak berpasangan tetapi n-tupel (atau mungkin daftar) harus dikumpulkan. Inilah pendekatan alternatif:

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

Menghasilkan daftar daftar

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

Tanpa itu filter(w -> w.count() == n), hasilnya pasti

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

Penafian: Saya bekerja untuk perusahaan di belakang jOOλ

Streams.zip(..)tersedia di Jambu biji , bagi yang bergantung padanya.

Contoh:

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

Kita bisa menggunakan RxJava ( pustaka ekstensi reaktif yang sangat kuat )

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

The penyangga Operator mengubah sebuah diamati yang memancarkan item menjadi diamati yang memancarkan buffered koleksi barang-barang ..

Operasi ini pada dasarnya stateful, jadi bukan apa yang harus diselesaikan oleh aliran - lihat bagian "Perilaku Tanpa Kewarganegaraan" di javadoc :

Pendekatan terbaik adalah menghindari parameter perilaku stateful untuk mengalirkan operasi seluruhnya

Salah satu solusinya di sini adalah memperkenalkan status dalam aliran Anda melalui penghitung eksternal, meskipun ini hanya akan berfungsi dengan aliran berurutan.

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 + '}'; }
}

Dalam kasus Anda, saya akan menulis IntFungsi kustom saya yang melacak int terakhir yang dilewati dan menggunakannya untuk memetakan IntStream asli.

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

  }

}

Untuk menghitung perbedaan berturut-turut dalam waktu (nilai-x) dari deret waktu, saya menggunakan metode stream's collect(...):

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

Di mana DifferenceCollector terlihat seperti ini:

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

Anda mungkin dapat memodifikasi ini agar sesuai dengan kebutuhan Anda.

Saya akhirnya menemukan cara untuk mengelabui Stream.reduce agar dapat menangani pasangan nilai dengan rapi; Ada banyak kasus penggunaan yang membutuhkan fasilitas ini yang tidak muncul secara alami di 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;
}

Trik yang saya gunakan adalah return right; pernyataan.

Solusi elegan adalah menggunakan zip . Sesuatu seperti:

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

Ini cukup ringkas dan elegan, namun menggunakan daftar sebagai masukan. Sumber aliran tak terbatas tidak dapat diproses dengan cara ini.

Masalah lain (yang lebih merepotkan) adalah bahwa zip bersama dengan seluruh kelas Stream akhir-akhir ini telah dihapus dari API. Kode di atas hanya bekerja dengan b95 atau rilis yang lebih lama. Jadi dengan JDK terbaru saya akan mengatakan tidak ada solusi gaya FP yang elegan dan saat ini kami hanya bisa berharap bahwa dalam beberapa cara zip akan diperkenalkan kembali ke API.

Ini masalah yang menarik. Apakah percobaan hybrid saya di bawah ada gunanya?

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

Saya yakin ini tidak cocok untuk pemrosesan paralel, dan karenanya dapat didiskualifikasi.

Seperti yang telah diamati orang lain, ada, karena sifat masalah, beberapa keadaan yang diperlukan.

Saya dihadapkan pada masalah serupa, di mana saya menginginkan apa yang pada dasarnya adalah fungsi LEAD Oracle SQL. Upaya saya untuk menerapkannya ada di bawah ini.

/**
 * 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();
}

Anda dapat mencapainya dengan menggunakan antrian terbatas untuk menyimpan elemen yang mengalir melalui aliran (yang mendasarkan pada ide yang saya jelaskan secara rinci di sini: Apakah mungkin untuk mendapatkan elemen berikutnya di Stream? )

Contoh di bawah ini pertama kali mendefinisikan instance kelas BoundedQueue yang akan menyimpan elemen melalui aliran (jika Anda tidak menyukai gagasan untuk memperluas LinkedList, lihat tautan yang disebutkan di atas untuk pendekatan alternatif dan yang lebih umum). Nanti Anda tinggal menggabungkan dua elemen berikutnya ke dalam contoh Pair:

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

Saya setuju dengan @aepurniet tetapi peta Anda harus menggunakan mapToObj

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

Jalankan forloop yang berjalan dari 0 ke length-1streaming Anda

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
}