Android从零开始学习Rxjava2（五）—— 变换运算符

rxjava2变换运算符

GroupBy

将一个Observable分拆为一些Observables集合，它们中的每一个发射原始Observable的一个子序列,GroupBy操作符将原始Observable分拆为一些Observables集合，它们中的每一个发射原始Observable数据序列的一个子序列。哪个数据项由哪一个Observable发射是由一个函数判定的，这个函数给每一项指定一个Key，Key相同的数据会被同一个Observable发射。

groupBy顾名思义是以xxx分组,groupBy的Function中，自定义分组逻辑将每个信息分配到对应的组，并将组的key标志返回。GroupedObservable就可以根据key来筛选获得对应组的元素。
举个例子：

private void doSomeWork() {
        Observable.range(0, 10)
                .groupBy(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return integer % 2 == 0 ? "分组key1" : "分组key2";
                    }
                }).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
            @Override
            public void accept(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) throws Exception {
                Log.d(TAG, " accept : key : " + stringIntegerGroupedObservable.getKey());
                if (stringIntegerGroupedObservable.getKey().equalsIgnoreCase("分组key1"))
                    stringIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                        @Override
                        public void accept(Integer integer) throws Exception {
                            Log.d(TAG, " accept : key : " + stringIntegerGroupedObservable.getKey() + ",value : " + integer);
                        }
                    });
            }
        });
    }

将奇数、偶数分组，偶数分组设置个key，key可以自定义，这里就叫分组key1；奇数分组key叫分组key2。
打印结果

accept : key : 分组key1
accept : key : 分组key1,value : 0
accept : key : 分组key2
accept : key : 分组key1,value : 2
accept : key : 分组key1,value : 4
accept : key : 分组key1,value : 6
accept : key : 分组key1,value : 8

Scan

按顺序发出每个连续的值,将该函数的结果作为其自己的第一个发射。然后 将函数的结果与源Observable发出的第二个项一起反馈到函数中，生成其第二个发射， 依此类推。

Scan扫描，它会顺序的发射元素，通过scan函数里面自定义的操作后，将自定义操作后的值作为第一个元素传到下次scan函数中。在某些情况下，这种运算符有时被称为“累加器”。所以我们举个累加的例子：

private void doSomeWork() {
        Observable.range(0, 5)
                .scan(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) throws Exception {
                        Log.d(TAG, " accept : integer : " + integer + ",integer2 : " + integer2);
                        return integer + integer2;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, " accept : integer : " + integer);
            }
        });
    }

打印结果

accept : integer : 0
accept : integer : 0,integer2 : 1
accept : integer : 1
accept : integer : 1,integer2 : 2
accept : integer : 3
accept : integer : 3,integer2 : 3
accept : integer : 6
accept : integer : 6,integer2 : 4
accept : integer : 10

通过打印的结果我们可以看到，scan发射元素是顺序执行的，并且会将函数的执行结果作为下一次函数的第一个参数。

Window

定期将Observable中的项目细分为Observable窗口并发出这些窗口，而不是一次发出一个项目。
Window类似于Buffer，但它不是从源Observable发出项目包，而是发出Observable，每个Observable都从源Observable发出一个项子集，然后用onCompleted通知终止。

举个例子，每三秒将缓冲的数据发射出来：

private void doSomeWork() {
        Observable.interval(1, TimeUnit.SECONDS).take(10)
                .window(3, TimeUnit.SECONDS)
                .subscribe(new Consumer<Observable<Long>>() {
                    @Override
                    public void accept(Observable<Long> longObservable) throws Exception {
                        Log.d(TAG, "Sub Divide begin....");
                        longObservable.subscribe(new Consumer<Long>() {
                            @Override
                            public void accept(Long aLong) throws Exception {
                                Log.d(TAG, " accept : aLong : " + aLong);
                            }
                        });
                    }
                });
    }

Sub Divide begin....
accept : aLong : 0
accept : aLong : 1
accept : aLong : 2
Sub Divide begin....
accept : aLong : 3
accept : aLong : 4
Sub Divide begin....
accept : aLong : 5
accept : aLong : 6
accept : aLong : 7
Sub Divide begin....
accept : aLong : 8
accept : aLong : 9

---

参考资料，参考但不局限以下链接
http://reactivex.io/documentation/operators.html#transforming