Raccogli le coppie successive da un flusso

Dato un flusso come { 0, 1, 2, 3, 4 } ,

come posso trasformarlo nel modo più elegante in una forma data:

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

(supponendo, ovviamente, di aver definito la classe Pair)?

Modifica: non si tratta strettamente di int o flussi primitivi. La risposta dovrebbe essere generale per un flusso di qualsiasi tipo.

La mia libreria StreamEx che estende i flussi standard fornisce un pairMapmetodo per tutti i tipi di flusso. Per i flussi primitivi non cambia il tipo di flusso, ma può essere utilizzato per eseguire alcuni calcoli. L'utilizzo più comune è calcolare le differenze:

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

Per il flusso di oggetti è possibile creare qualsiasi altro tipo di oggetto. La mia libreria non fornisce nuove strutture di dati visibili all'utente come Pair(questa è la parte del concetto di libreria). Tuttavia, se hai la tua Pairclasse e desideri utilizzarla, puoi fare quanto segue:

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

O se ne hai già alcuni Stream:

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

Questa funzionalità viene implementata utilizzando uno spliteratore personalizzato . Ha un overhead piuttosto basso e può parallelizzare bene. Ovviamente funziona con qualsiasi sorgente di flusso, non solo con elenchi / array di accesso casuale come molte altre soluzioni. In molti test funziona davvero bene. Ecco un benchmark JMH in cui troviamo tutti i valori di input che precedono un valore più grande utilizzando approcci diversi (vedi questa domanda).

La libreria di flussi Java 8 è principalmente orientata alla suddivisione dei flussi in blocchi più piccoli per l'elaborazione parallela, quindi le fasi della pipeline con stato sono piuttosto limitate e non sono supportate operazioni come ottenere l'indice dell'elemento del flusso corrente e accedere agli elementi del flusso adiacenti.

Un modo tipico per risolvere questi problemi, con alcune limitazioni, ovviamente, è guidare il flusso per indici e fare affidamento sul fatto che i valori vengano elaborati in una struttura di dati ad accesso casuale come un ArrayList da cui è possibile recuperare gli elementi. Se i valori fossero in arrayList, si potrebbero generare le coppie come richiesto facendo qualcosa del genere:

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

Ovviamente la limitazione è che l'input non può essere un flusso infinito. Tuttavia, questa pipeline può essere eseguita in parallelo.

Non è elegante, è una soluzione hacker, ma funziona per flussi infiniti

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

Ora puoi limitare il tuo streaming alla lunghezza che desideri

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

PS Spero che ci sia una soluzione migliore, qualcosa come clojure(partition 2 1 stream)

Ho implementato un wrapper spliterator che prende tutti gli nelementi Tdallo spliterator originale e produce 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();
    }
}

Il seguente metodo può essere utilizzato per creare uno stream consecutivo:

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

Utilizzo del campione:

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

Puoi farlo con il metodo Stream.reduce () (non ho visto altre risposte usando questa tecnica).

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

Puoi farlo in cyclops-react (contribuisco a questa libreria), usando l'operatore di scorrimento.

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

O

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

Supponendo che il costruttore della coppia possa accettare una raccolta con 2 elementi.

Se si desidera raggruppare per 4 e incrementare di 2, anche questo è supportato.

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

Metodi statici equivalenti per la creazione di una visualizzazione scorrevole su java.util.stream.Stream sono forniti anche nella classe StreamUtils di cyclops-streams .

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

Nota: - per il funzionamento a thread singolo ReactiveSeq sarebbe più appropriato. LazyFutureStream estende ReactiveSeq ma è principalmente orientato all'uso simultaneo / parallelo (è uno Stream of Futures).

LazyFutureStream estende ReactiveSeq che estende Seq dal fantastico jOOλ (che estende java.util.stream.Stream), quindi le soluzioni presentate da Lukas funzionerebbero anche con entrambi i tipi di Stream. Per chiunque sia interessato, le differenze principali tra gli operatori finestra / scorrevole sono l'ovvio rapporto potenza / complessità relativo e l'idoneità per l'uso con flussi infiniti (lo scorrimento non consuma il flusso, ma buffer mentre scorre).

La libreria proton-pack fornisce la funzionalità a finestra. Data una classe Pair e uno Stream, puoi farlo in questo modo:

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

Ora lo pairsstream contiene:

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

Trovare coppie successive

Se sei disposto a utilizzare una libreria di terze parti e non hai bisogno del parallelismo, jOOλ offre le funzioni della finestra in stile SQL come segue

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

cedimento

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

Il lead() funzione accede al valore successivo in ordine trasversale dalla finestra.

Trovare successive triple / quadruple / n-tuple

Una domanda nei commenti chiedeva una soluzione più generale, in cui non dovrebbero essere raccolte coppie ma n-tuple (o possibilmente elenchi). Ecco quindi un approccio alternativo:

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

Fornire un elenco di elenchi

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

Senza il filter(w -> w.count() == n), il risultato sarebbe

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

Disclaimer: lavoro per l'azienda dietro jOOλ

Streams.zip(..) è disponibile in Guava , per coloro che dipendono da esso.

Esempio:

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

Possiamo usare RxJava ( libreria di estensioni reattive molto potente )

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

L' operatore buffer trasforma un Observable che emette elementi in un Observable che emette raccolte bufferizzate di quegli elementi.

L'operazione è essenzialmente stateful, quindi non proprio ciò che i flussi dovrebbero risolvere - vedere la sezione "Stateless Behaviors" nel javadoc :

L'approccio migliore è evitare completamente i parametri comportamentali stateful per eseguire lo streaming delle operazioni

Una soluzione qui è introdurre lo stato nel flusso tramite un contatore esterno, sebbene funzionerà solo con un flusso sequenziale.

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

Nel tuo caso, scriverei la mia IntFunction personalizzata che tiene traccia dell'ultimo int passato e lo userei per mappare l'IntStream originale.

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

  }

}

Per calcolare le differenze successive nel tempo (valori x) di una serie temporale, utilizzo il metodo streams collect(...):

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

Dove DifferenceCollector è qualcosa del genere:

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

Probabilmente potresti modificarlo in base alle tue esigenze.

Alla fine ho trovato un modo per ingannare Stream.reduce per essere in grado di gestire ordinatamente coppie di valori; ci sono una moltitudine di casi d'uso che richiedono questa funzionalità che non appare naturalmente in 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;
}

Il trucco che uso è il diritto di ritorno; dichiarazione.

Una soluzione elegante sarebbe usare zip . Qualcosa di simile a:

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

Questo è abbastanza conciso ed elegante, tuttavia utilizza un elenco come input. Una sorgente di flusso infinita non può essere elaborata in questo modo.

Un altro problema (molto più problematico) è che lo zip insieme all'intera classe Streams è stato recentemente rimosso dall'API. Il codice sopra funziona solo con b95 o versioni precedenti. Quindi con l'ultimo JDK direi che non esiste un'elegante soluzione in stile FP e in questo momento possiamo solo sperare che in qualche modo zip venga reintrodotto nell'API.

Questo è un problema interessante. Il mio tentativo ibrido è buono?

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

Credo che non si presti all'elaborazione parallela e quindi possa essere squalificato.

Come altri hanno osservato, a causa della natura del problema è richiesta una certa staticità.

Mi sono trovato di fronte a un problema simile, in cui volevo quella che era essenzialmente la funzione Oracle SQL LEAD. Il mio tentativo di implementarlo è di seguito.

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

È possibile ottenere ciò utilizzando una coda delimitata per memorizzare gli elementi che fluiscono attraverso il flusso (che si basa sull'idea che ho descritto in dettaglio qui: è possibile ottenere l'elemento successivo nello stream? )

L'esempio seguente definisce prima l'istanza della classe BoundedQueue che memorizzerà gli elementi che passano attraverso il flusso (se non ti piace l'idea di estendere la LinkedList, fai riferimento al collegamento menzionato sopra per un approccio alternativo e più generico). Successivamente combini solo due elementi successivi nell'istanza di 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);
  }
}

Sono d'accordo con @aepurniet ma invece map devi usare mapToObj

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

Esegui un forciclo che va da 0 a length-1del tuo flusso

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
}