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理解三