Rxjava2 操作符 - Transforming Observable

本教程均是基于java的项目：

Buffer — 周期性收集Obserable产生结果到集合中，并一次性发送它。

    private static void buffer() {
        ArrayList list = new ArrayList<>();
        for (int i = 1; i < 11; i++) {
            list.add(i);
        }
        Observable
                .fromIterable(list)
                .buffer(2, 3) //一次收集2个，下次跳过3个收集
                .subscribe(new Consumer>() {
                    @Override
                    public void accept(List integers) throws Exception {
                        for (Integer integer : integers) {
                            System.out.println("accept: " + integer);
                        }
                    }
                });
    }

输出结果：

accept: 1
accept: 2
accept: 4
accept: 5
accept: 7
accept: 8
accept: 10

FlatMap — 可以应用一个函数把Observable事件转换到Observables，然后再通过一个Obserable发射出去，需要注意flatMap 并不能保证事件的顺序。

    private static void flatMap() {
        Observable
                .just(1, 2, 3, 4, 5)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .flatMap(new Function>() {
                    @Override
                    public ObservableSource apply(@NonNull Integer integer) throws Exception {
                        System.out.println(Thread.currentThread() + " apply " + integer);
                        return Observable.just("this is " + integer).delay(3, TimeUnit.SECONDS);
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println(Thread.currentThread() + " accept: " + s);
                    }
                });
        while (true) ;
    }

输出结果：

Thread[RxCachedThreadScheduler-2,5,main] apply 1
Thread[RxCachedThreadScheduler-2,5,main] apply 2
Thread[RxCachedThreadScheduler-2,5,main] apply 3
Thread[RxCachedThreadScheduler-2,5,main] apply 4
Thread[RxCachedThreadScheduler-2,5,main] apply 5
Thread[RxComputationThreadPool-2,5,main] accept: this is 2
Thread[RxComputationThreadPool-2,5,main] accept: this is 3
Thread[RxComputationThreadPool-4,5,main] accept: this is 4
Thread[RxComputationThreadPool-1,5,main] accept: this is 1
Thread[RxComputationThreadPool-1,5,main] accept: this is 5

可以看到我们apply的时候是1 2 3 4 5，订阅收到的确是2 3 4 1 5，可能下一次运行又不是这个顺序了，需要保证顺序则可以使用 concatMap替换flatMap。

Map — 通过一个函数（apply）转换通过Observable发射的项目。

    private static void map() {
        Observable
                .just(1, 2, 3, 4, 5)
                .map(new Function() {
                    @Override
                    public String apply(@NonNull Integer integer) throws Exception {
                        return "result " + integer;
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(String s) throws Exception {
                        System.out.println("accept " + s);
                    }
                });
    }

输出结果：

accept result 1
accept result 2
accept result 3
accept result 4
accept result 5

GroupBy — 对源Observable结果分组，转换成GroupedObservable的结果集，GroupedObservable中存在一个方法为getKey()，可以通过该方法获取结果集的Key值。
由于GroupedObservable是把分组结果缓存起来，如果对每一个GroupedObservable不进行处理（既不订阅执行也不对其进行别的操作符运算），就有可能出现内存泄露。所以你对某个GroupedObservable不进行处理，最好是对其使用操作符take(0)处理。

    private static void groupBy() {
        Observable
                .range(0, 9)
                .groupBy(new Function() {
                    @Override
                    public Integer apply(@NonNull Integer value) throws Exception {
                        return value % 3;   //返回值决定组名 这里分了0 1 2三组
                    }
                })
                .subscribe(new Consumer>() {
                    @Override
                    public void accept(final GroupedObservable res) throws Exception {
                        res.subscribe(new Consumer() {
                            @Override
                            public void accept(Integer aLong) throws Exception {
                                System.out.println("group: " + res.getKey() + " - " + aLong);
                            }
                        });
                    }
                });
    }

输出结果：

group: 0 - 0
group: 1 - 1
group: 2 - 2
group: 0 - 3
group: 1 - 4
group: 2 - 5
group: 0 - 6
group: 1 - 7
group: 2 - 8

Scan — scan对迭代源Observable产生的结果应用一个函数，将结果发射出去并作为下次迭代的一个参数。

    private static void scan() {
        Observable
                .just(1, 2, 3, 4, 5)
                .scan(new BiFunction() {
                    @Override
                    public Integer apply(@NonNull Integer sum, @NonNull Integer item) throws Exception {
                        System.out.println("sum " + sum);
                        return sum + item;
                    }
                })
                .subscribe(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("Next: " + integer);
                    }
                });
    }

输出结果：

Next: 1
sum 1
Next: 3
sum 3
Next: 6
sum 6
Next: 10
sum 10
Next: 15

Window — 类似于buffer，区别在于buffer操作符产生的结果是一个List缓存，而window操作符产生的是一个Observable，订阅者可以对这个结果Observable重新进行订阅处理

    private static void window() {
        ArrayList list = new ArrayList<>();
        for (int i = 1; i < 11; i++) {
            list.add(i);
        }
        Observable
                .fromIterable(list)
                .window(2, 3)
                .subscribe(new Consumer>() {
                    @Override
                    public void accept(Observable ob) throws Exception {
                        ob.subscribe(new Consumer() {
                            @Override
                            public void accept(Integer integer) throws Exception {
                                System.out.println("accept: " + integer);
                            }
                        });
                    }
                });

    }

输出结果：

accept: 1
accept: 2
accept: 4
accept: 5
accept: 7
accept: 8
accept: 10