Зберіть послідовні пари з потоку

Даний потік, наприклад { 0, 1, 2, 3, 4 },

як я можу найелегантніше перетворити його на задану форму:

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

(якщо, звичайно, я визначив пару класу)?

Редагувати: мова йде не лише про вбудовані або примітивні потоки. Відповідь повинна бути загальною для потоку будь-якого типу.

Моя бібліотека 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 Я сподіваюся, що є краще рішення, щось на зразок клоджура(partition 2 1 stream)

Я реалізував оболонку spliterator, яка бере всі 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;
}

Це можна зробити за допомогою циклоп-реакції (я сприяю цій бібліотеці), використовуючи оператор ковзання.

  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 також передбачені в циклоп-потоках класу StreamUtils .

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

Примітка: - для однопотокової роботи ReakicaSeq було б більш доцільним. LazyFutureStream розширює ReactiveSeq, але в першу чергу орієнтований на паралельне / паралельне використання (це Потік майбутнього).

LazyFutureStream розширює ReactiveSeq, що розширює Seq від дивовижного jOOλ (який розширює java.util.stream.Stream), тому рішення подарунків Лукаша також будуть працювати з будь-яким типом Stream. Для всіх, хто цікавиться первинними відмінностями між операторами вікна / ковзання є очевидна відносна потужність / складність відключення та придатність для використання з нескінченними потоками (ковзання не споживає потік, а буфери, коли він тече).

Бібліотека proton-pack надає віконну функціональність. Враховуючи клас пари та потік, ви можете це зробити так:

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 :

Найкращий підхід - уникнути стаціонарних параметрів поведінки, щоб повністю передавати операції

Одне тут рішення - ввести стан у потоці через зовнішній лічильник, хоча воно буде працювати лише з послідовним потоком.

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

У вашому випадку я б написав свій власний IntFunction, який відслідковує останній переданий int, і використовувати його для відображення оригінальної 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) часового ряду я використовую метод streams 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;
}

Трюк, який я використовую, - це повернути право; заява.

Елегантним рішенням буде використання блискавки . Щось на зразок:

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

Це досить стисло та елегантно, проте він використовує список як вхідний текст. Нескінченне джерело потоку не може бути оброблене таким чином.

Ще одне (набагато більш клопітке) питання полягає в тому, що поштовий індекс разом із усім класом Streams останнім часом видалено з API. Вищевказаний код працює лише з версіями b95 або старішими. Отже, з останнім JDK я б сказав, що не існує елегантного рішення у стилі FP, і зараз ми можемо просто сподіватися, що якийсь поштовий індекс буде знову введений в 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, зверніться до вищезазначеного посилання для альтернативного та більш загального підходу). Пізніше ви просто комбінуєте два наступні елементи в екземпляр 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);
  }
}

Я погоджуюся з @aepurniet, але замість цього вам потрібно використовувати mapToObj

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

Запустіть forцикл, який працює від 0 до 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
}