Java Stream相当于ReactiveX Observable＃scan

Question

ReactiveX has this Very Neat operator called Scan , which is like reduce, except it emits each intermediate accumulator.

How would I accomplish this with Java Streams? Stream#reduce is not what I want because it returns T :

T reduce(T identity, BinaryOperator<T> accumulator)

And what I want is to return Stream<T> , with each item of the stream being the T that was returned on each invocation of the accumulator :

Stream.of(1, 2, 3)
    .myScan(0, (accumulator, i) -> accumulator + i)
    .collect(Collectors.toList()); // [1, 3, 6]

I could do something lame like reducing a List , then convert back to a Stream , but that's ugly.

Answer 1

Stream does not support this operation. You could convert it to an iterator, do it there, and convert back to streams, but there is nothing built-in for streams to do this.

Answer 2

Try StreamEx . I think it provides the extract API you want:

List<Integer> result = StreamEx.of(1, 2, 3).scanLeft((i, j) -> i + j);
System.out.println(result); // [1, 3, 6]

Answer 3

You could try to benefit from otherwise discouraged side-effects . Since your goal is to process the stream and keeping going on with a stream, we can achieve this using the map method. The following code does it utilizing a side-effect.

public class Scan {

  public static void main(String[] args) {
    Accumulator accumulator = new Accumulator();

    Stream<Integer> originalStream = Stream.of(1, 2, 3);
    Stream<Integer> scannedStream = originalStream
      .map(i -> accumulator.accumulate(i));
    List<Integer> list = scannedStream
      .collect(Collectors.toList()); // [1, 3, 6]

    for (Integer i : list) {
      System.out.println(i);
    }
  }

  private static class Accumulator {

    private int value;

    public int accumulate(int i) {
      return value += i;
    }

  }
}

The Accumulator can be replaced by a Function to be used for different scan -operations.

But you have to be aware of the restrictions and concerns (eg thread-safty).

Answer 4

The biggest problem of java-stream is that is overrated and understood as a magic-bullet solution for everything slightly related to any of Collection.

This API has been build for the supporting sequential processing of the elements. There doesn't exist any Stream-alike method performing the snippet below. Moreover, this API is not easily extendable.

Here is what you are speaking about:

List<Integer> list = new ArrayList<>();
Stream.of(1, 2, 3).reduce(0, (t, u) -> {
    final Integer s = t + u;
    list.add(s);
    return s;
});

System.out.println(list);   // prints [1, 3, 6]

And here is a workaround using AtomicInteger which allows you to continue the streaming after performing the map(..) :

AtomicInteger sum = new AtomicInteger(0);
List<Integer> list = Stream.of(1, 2, 3)
    .map(i -> sum.addAndGet(i))
    .collect(Collectors.toList()); 

System.out.println(list);  // prints [1, 3, 6]

Sometimes you have to use different way.