The code above has a problem with a formality: `reduce` is meant to be a functional fold and folds are not supposed to work on mutable accumulators. If we were to do this the "right" way, we would have to create a new instance of `ArrayList<Integer>` for every new item, like this:

.reduce(

new ArrayList<Integer>(),

(acc, value) -> {

ArrayList<Integer> newAcc = (ArrayList<Integer>) acc.clone();

newAcc.add(value);

return newAcc;

})

The performance of creating a new collection for every new item is unacceptable. For that reason, Rx offers the `collect` operator, which does the same thing as `reduce`, only using a mutable accumulator this time. By using `collect` you document that you are not following the convention of immutability and you also simplify your code a little:

Observable<Integer> values = Observable.range(10,5);

values

.collect(

() -> new ArrayList<Integer>(),

(acc, value) -> acc.add(value))

.subscribe(v -> System.out.println(v));

Usually, you won't have to collect values manually. Rxjava offers a variety of operators for collecting your sequence into a container. Those aggregators return an observable that will emit the corresponding collection when it is ready.