从流中收集连续对

给定流如 { 0, 1, 2, 3, 4 }，

如何最优雅地将其转换为给定形式：

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

（当然，假设我已经定义了Pair类）？

编辑：这不完全是关于整数或原始流。对于任何类型的流，答案应该是通用的。

我的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）中处理值，可以从中检索元素。如果值为in 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;
}

您可以使用滑动运算符在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个元素的Collection。

如果要按4分组，也可以按2递增。

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

在cyclops-streams StreamUtils类中还提供了用于在java.util.stream.Stream上创建滑动视图的等效静态方法。

       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(..)可以在Guava中使用，供依赖它的人使用。

例：

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值）的连续差异，我使用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)
);

这非常简洁，优雅，但是它使用列表作为输入。无限流源无法通过这种方式进行处理。

另一个（更麻烦的是）问题是，最近将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();
}

您可以通过使用有界队列来存储流经流的元素来实现这一点（基于我在这里详细描述的思想：是否可以在Stream中获取下一个元素？）

下面的示例首先定义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来代替map

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
}