Rxjava从使用到原码的解析四: Rxjava变换型操作符

Rxjava变换型操作符: RxJava从上游发射事件到下游接收事件过程中对进行事件变换.创建变换操作符主要有以下几种

map

        Observable.just(1, 2)//内部会先发送A再发送B
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return "[" + integer + "]";
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.e(TAG, s);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

开始泛型1,2为Integer类型,然后通过map操作符转换一次后,变成了String类型,最后下游接收到的也是string,变换操作符可以使用多次.

flapMap

        Observable.just(1)//内部会先发送A再发送B
               
                .flatMap(new Function<Integer, ObservableSource<String>>() {

                    @Override
                    public ObservableSource<String> apply(final Integer integer) throws Exception {
                        return Observable.create(new ObservableOnSubscribe<String>() {
                            @Override
                            public void subscribe(ObservableEmitter<String> e) throws Exception {
                                e.onNext(integer + "integer");
                                e.onNext(integer + "integer");
                                e.onNext(integer + "integer");
                            }
                        });
                    }
                })
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, s);
                    }
                })

通过flagMap操作符之后,他又生成了新的被观察者, 这里又可以发送事件也就是拦截了上游发过来的事件,再自己操作事件发给下游

concatMap:  他和flagMap一样 唯一的区别就是事件是排序的

比如上游发射了A B C 三个事件出来,通过concatMap拦截后,他们有顺序的拦截再发射, 一定是先拦截A再B再C

groupBy

Disposable subscribe = Observable.just(6000, 7000, 8000, 9000, 10000)

                .groupBy(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return integer > 8000 ? "高端" : "低端";
                    }
                })
                .subscribe(new Consumer<GroupedObservable<String, Integer>>() {
                    @Override
                    public void accept(final GroupedObservable<String, Integer> observable) throws Exception {
                        Log.e(TAG, observable.getKey());//这里可以打印的是高端和低端
                        Disposable subscribe1 = observable.subscribe(new Consumer<Integer>() {
                            @Override
                            public void accept(Integer integer) throws Exception {
                                //这里会 打印出高端和价格 
                                Log.e(TAG, observable.getKey()+"  " + integer);
                            }
                        });
                    }
                });

上面就是能过groupBy将价格按照高端和低端进行分组.

buffer

        //很多数据不想全部发射出去,想分批次发
        Disposable subscribe = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                for (int i = 0; i < 100; i++) {
                    e.onNext(i);
                }
            }
        })
                .buffer(20)
                .subscribe(new Consumer<List<Integer>>() {
                    @Override
                    public void accept(List<Integer> integers) throws Exception {
                        Log.e(TAG, "accept " + integers);
                    }
                });

上面一共发射了100个事件,使用buffe操作后,就会20  20 分组 一共5组,最后在accept里就会输出5次

 

Rxjava理解一

Rxjava理解二

Rxjava理解三