Bir akıştan ardışık çiftler toplayın

Gibi bir akış verildiğinde { 0, 1, 2, 3, 4 },

onu en zarif şekilde verilen forma nasıl dönüştürebilirim:

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

(tabii ki, çift sınıfını tanımladığımı varsayarak)?

Düzenleme: Bu kesinlikle girişler veya ilkel akışlarla ilgili değildir. Cevap, her türden bir akış için genel olmalıdır.

Standart akışları genişleten My StreamEx kitaplığı pairMap, tüm akış türleri için bir yöntem sağlar . İlkel akışlar için akış türünü değiştirmez, ancak bazı hesaplamalar yapmak için kullanılabilir. En yaygın kullanım, farklılıkları hesaplamaktır:

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

Nesne akışı için herhangi bir başka nesne türü oluşturabilirsiniz. Kitaplığım, Pair(bu, kütüphane konseptinin bir parçasıdır) gibi kullanıcı tarafından görülebilen yeni veri yapıları sağlamıyor . Ancak kendi Pairsınıfınız varsa ve onu kullanmak istiyorsanız, aşağıdakileri yapabilirsiniz:

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

Veya zaten varsa Stream:

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

Bu işlevsellik, özel ayırıcı kullanılarak uygulanır . Oldukça düşük bir ek yüke sahiptir ve güzel bir şekilde paralel olabilir. Tabii ki, diğer birçok çözüm gibi sadece rastgele erişim listesi / dizisi ile değil, herhangi bir akış kaynağıyla çalışır. Birçok testte gerçekten iyi performans gösteriyor. İşte farklı yaklaşımlar kullanılarak daha büyük bir değere önceki tüm giriş değerleri bulmak nerede bir JMH kriter (bkz bu soruyu).

Java 8 akış kitaplığı esas olarak akışları paralel işleme için daha küçük parçalara bölmeye yöneliktir, bu nedenle durum bilgisi olan işlem hattı aşamaları oldukça sınırlıdır ve mevcut akış öğesinin dizinini almak ve bitişik akış öğelerine erişmek gibi şeyler yapmak desteklenmez.

Kuşkusuz, bazı sınırlamalarla birlikte bu sorunları çözmenin tipik bir yolu, akışı indekslerle çalıştırmak ve değerlerin, öğelerin geri alınabileceği bir ArrayList gibi bazı rasgele erişimli veri yapısında işlenmesine güvenmektir. Değerler içeride olsaydı, aşağıdaki arrayListgibi bir şey yaparak istendiği gibi çiftler üretilebilirdi:

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

Elbette sınırlama, girdinin sonsuz bir akış olamayacağıdır. Yine de bu boru hattı paralel olarak çalıştırılabilir.

Bu zarif değil, hack'lenmiş bir çözüm, ancak sonsuz akışlar için çalışıyor

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

Artık yayınınızı istediğiniz uzunlukta sınırlayabilirsiniz

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

Not: Umarım daha iyi bir çözüm vardır, tıkanma gibi bir şey(partition 2 1 stream)

Orijinal ayırıcıdan her nöğeyi Talan ve üreten bir ayırıcı sarıcı uyguladım 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();
    }
}

Ardışık bir akış oluşturmak için aşağıdaki yöntem kullanılabilir:

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

Örnek kullanım:

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

Bunu Stream.reduce () yöntemiyle yapabilirsiniz (Bu tekniği kullanan başka bir yanıt görmedim).

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

Bunu cyclops-react'te (bu kitaplığa katkıda bulunuyorum) kaydırma operatörünü kullanarak yapabilirsiniz.

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

Veya

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

Pair yapıcısının 2 öğeli bir Koleksiyonu kabul edebileceğini varsayarsak.

4'e göre gruplamak ve 2'ye kadar artırmak istiyorsanız, bu da desteklenir.

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

Java.util.stream.Stream üzerinde kayan bir görünüm oluşturmak için eşdeğer statik yöntemler, cyclops -streams StreamUtils sınıfında da sağlanır .

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

Not: - tek iş parçacıklı işlem için ReactiveSeq daha uygun olacaktır. LazyFutureStream, ReactiveSeq'i genişletir, ancak öncelikle eşzamanlı / paralel kullanım için tasarlanmıştır (bu bir Vadeli İşlem Akışıdır).

LazyFutureStream, Seq'i harika jOOλ'dan (java.util.stream.Stream'i genişleten) genişleten ReactiveSeq'i genişletir, böylece Lukas'ın sunduğu çözümler her iki Stream türü ile de çalışır. İlgilenen herkes için pencere / kayan operatörler arasındaki temel farklar, açık göreceli güç / karmaşıklık değiş tokuşu ve sonsuz akışlarla kullanıma uygunluktur (kayma akışı tüketmez, ancak akarken tamponlar).

Proton-pack kütüphane pencereli functionnality sağlar. Bir Pair sınıfı ve bir Akış verildiğinde, bunu şu şekilde yapabilirsiniz:

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

Artık pairsakış şunları içerir:

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

Ardışık çiftleri bulmak

Üçüncü taraf bir kitaplık kullanmak istiyorsanız ve paralelliğe ihtiyacınız yoksa, jOOλ aşağıdaki gibi SQL tarzı pencere işlevleri sunar

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

Verimli

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

lead()Fonksiyon penceresinden kastetmek için sonraki değeri erişir.

Ardışık üçlü / dörtlü / n-tupleleri bulma

Yorumlardaki bir soru, çiftlerin değil n-tuplelerin (veya muhtemelen listelerin) toplanması gereken daha genel bir çözüm istiyordu. İşte alternatif bir yaklaşım:

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

Bir liste listesi oluşturma

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

Olmadan filter(w -> w.count() == n)sonuç şöyle olur

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

Sorumluluk reddi: jOOλ'nın arkasındaki şirket için çalışıyorum

Streams.zip(..)buna güvenenler için Guava'da mevcuttur .

Misal:

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

Biz kullanabilirsiniz RxJava (çok güçlü reaktif uzatma kütüphanesi)

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

Tampon operatörü bir gözlemlenebilir içine yayar ürün yayar bu öğelerin koleksiyonları tamponlu o bir gözlemlenebilir dönüştüren ..

Operasyon yani gerçekten akışları çözmek için ne anlama geldiğini aslında durumsal olması - in "Vatansız Davranışlar" bölümüne bakın javadoc :

En iyi yaklaşım, işlemlerin tamamen akışını sağlamak için durum bilgisi olan davranış parametrelerinden kaçınmaktır.

Buradaki bir çözüm, akışınıza durumu harici bir sayaç aracılığıyla tanıtmaktır, ancak bu yalnızca sıralı bir akışla çalışacaktır.

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

Sizin durumunuzda, geçirilen son int'in kaydını tutan ve bunu orijinal IntStream'i eşlemek için kullanan özel IntFunction'ımı yazardım.

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

  }

}

Bir zaman-serisi zaman (x değerleri) birbirini takip eden farkların hesaplanması için, kullanımı stream'in collect(...)yöntemi:

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

DifferenceCollector'ın böyle bir şey olduğu yerde:

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

Muhtemelen bunu ihtiyaçlarınıza uyacak şekilde değiştirebilirsiniz.

Sonunda, Değer çiftleriyle düzgün bir şekilde başa çıkabilmek için Stream.reduce'u kandırmanın bir yolunu buldum; JDK 8'de doğal olarak görünmeyen bu özelliği gerektiren çok sayıda kullanım durumu vardır :

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

Kullandığım numara geri dönüş hakkı; Beyan.

Zip kullanmak zarif bir çözüm olacaktır . Gibi bir şey:

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

Bu oldukça özlü ve zariftir, ancak girdi olarak bir liste kullanır. Sonsuz bir akış kaynağı bu şekilde işlenemez.

Diğer bir (çok daha zahmetli) sorun, tüm Streams sınıfıyla birlikte zip'in son zamanlarda API'den kaldırılmış olmasıdır. Yukarıdaki kod yalnızca b95 veya daha eski sürümlerde çalışır. Bu yüzden, en son JDK ile şık bir FP tarzı çözüm olmadığını söyleyebilirim ve şu anda sadece bir şekilde zip'in API'ye yeniden ekleneceğini umabiliriz.

Bu ilginç bir sorundur. Benim mi hibrid hiçbir üründe aşağıda girişimi?

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

Paralel işlemeye uygun olmadığına inanıyorum ve bu nedenle diskalifiye edilebilir.

Başkalarının da gözlemlediği gibi, sorunun doğası gereği, bazı durumsallık gereklidir.

Esasen Oracle SQL işlevi LEAD olanı istediğim benzer bir sorunla karşı karşıya kaldım. Bunu uygulama girişimim aşağıdadır.

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

Akış boyunca akan öğeleri depolamak için sınırlı bir kuyruk kullanarak bunu başarabilirsiniz (bu, burada ayrıntılı olarak açıkladığım fikre dayanmaktadır: Akışta bir sonraki öğeyi elde etmek mümkün müdür? )

Aşağıdaki örnek ilk olarak akıştan geçen öğeleri depolayacak BoundedQueue sınıfının örneğini tanımlar (LinkedList'i genişletme fikrinden hoşlanmıyorsanız, alternatif ve daha genel yaklaşım için yukarıda belirtilen bağlantıya bakın). Daha sonra, sonraki iki öğeyi Eş örneğinde birleştirirsiniz:

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'e katılıyorum ancak bunun yerine mapToObj kullanmanız gerekiyor

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

for0'dan length-1akışınızın sonuna kadar uzanan bir döngü çalıştırın

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
}