RxJava2基础教程2-操作符2

这一节 接着看RxJava的操作符，官网地址，有事没事看点英文也挺好。
map: map转换符，这个map操作符很简单，进行一些数据的转换：

Observable.just(1, 2, 3)
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer * 2;
            }
        }).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer s) throws Exception {
        Log.i(TAG, "accept:  s = "  + s);
    }
});
    
    结果：
     accept:  s = 2
     accept:  s = 4
     accept:  s = 6

map操作符其实很常用，在我们请求网络数据之后，或者查询数据库之后，可以把相应的数据转换成ben对象等对数据进行处理

flatMap：flatMam是一个很用的转换器，他可以将一个observable转换为多个observable,并在这多个observable做你想做的操作：

 Observable.fromArray(1, 2)
        .flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final int t = integer;
                return new Observable<String>() {
                    @Override
                    protected void subscribeActual(Observer<? super String> observer) {
                        observer.onNext(t * 2 + "");
                        observer.onNext(t * 3 + "");
                    }
                };
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, "accept: s = "  + s);
            }
        });
        
    //结果如下,实际上转换成了两个发射器，所以必然打印四个数字：
     accept: s = 2
     accept: s = 3
     accept: s = 4
     accept: s = 6

buffer： buffer这个操作符是一个集合操作符，可以把数据缓存成集合：

 Observable.fromArray(1, 2, 3)
        .buffer( 3, 1)
        .subscribe(new Consumer<List<Integer>>() {
            @Override
            public void accept(List<Integer> integers) throws Exception {
                Log.i(TAG, "accept: " + integers.toString());
            }
        });
    结果如下：
     accept: [1, 2, 3]
     accept: [2, 3]
     accept: [3]

如果buffer(3, 1)后面的1去掉的话那么久一次全部打印出出来，就结束了。

scan： scan这个操作符的作用会根据前两个数据的结果发射给观察者，并把这个结果进行下一次的运算，说起来有点绕，看下面的例子：

     Observable.fromArray(1, 2, 3)
                .scan(new BiFunction<Integer, Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer, Integer integer2) throws Exception {
                        return integer + integer2;
                    }
                }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.i(TAG, "accept: integer = " + integer);
            }
        });
        
    结果：
     accept: integer = 1
     accept: integer = 3
     accept: integer = 6

卡可能已看出，第一次输出1，第二次输出1 + 2 = 3，第三次是3 + 3 = 6

groupBy：groupBy这个操作符根据字面意思来说 就是分组的意思，将被观察者按一定的条件进行分组，这个条件叫做key：

    Observable.fromArray(1, 2, 3, 4, 5, 6 ,7)
                .groupBy(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer) throws Exception {
                        return integer  % 2;
                    }
                }).subscribe(new Consumer<GroupedObservable<Integer, Integer>>() {
            @Override
            public void accept(GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) throws Exception {
                if(integerIntegerGroupedObservable.getKey() == 0){
                    integerIntegerGroupedObservable.subscribe(new Consumer<Integer>() {
                        @Override
                        public void accept(Integer integer) throws Exception {
                            Log.i(TAG, "accept: integer  = " + integer);
                        }
                    });
                }else{
                    Log.i(TAG, "accept:  奇数");
                }
            }
        });
    结果：
     奇数
    integer  = 2
    integer  = 4
    integer  = 6

上面的代码中按奇数和偶数进行分组，key想相同的放到同一个observable中，分组之后按组发射给下游的观察者