RxJava 2.X几个简单的操作符释义

RxJava 2.X几个简单的操作符释义

---

闲暇，写点东西。
RxJava本人就几个常见操作符写几个简单的使用示例，分别是***create,zip,map***

1，create操作符应该算最常见的操作符，用于生产一个发射对象
2，zip操作符合并事件专用，分别从两个上游事件中各取出一个组合，一个事件只能被使 次，顺序严格按照事件发送的顺序，最终下游事件收到的是和上游事件最少的数目相同（必须 两两配对，多余的舍弃)
3，map操作符也算是RxJava中常见的操作符，主要作用是对上游发送的每一个事件应用一个函数，使得每一个事件都按照指定的函数去变化，比如发射数据是String类型，而你可以用map来转int类型。具体直接上例子了，顺序结合例子看

Create操作符

  Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
            mRxOperatorsText.append("Observable emit 1" + "\n");
            Log.e(TAG, "Observable emit 1" + "\n");
            e.onNext(1);
            mRxOperatorsText.append("Observable emit 2" + "\n");
            Log.e(TAG, "Observable emit 2" + "\n");
            e.onNext(2);
            mRxOperatorsText.append("Observable emit 3" + "\n");
            Log.e(TAG, "Observable emit 3" + "\n");
            e.onNext(3);
            e.onComplete();
            mRxOperatorsText.append("Observable emit 4" + "\n");
            Log.e(TAG, "Observable emit 4" + "\n" );
            e.onNext(4);
        }
    }).subscribe(new Observer<Integer>() {
        private int i;
        private Disposable mDisposable;

        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("onSubscribe : " + d.isDisposed() + "\n");
            Log.e(TAG, "onSubscribe : " + d.isDisposed() + "\n" );
            mDisposable = d;
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("onNext : value : " + integer + "\n");
            Log.e(TAG, "onNext : value : " + integer + "\n" );
            i++;
            if (i == 2) {
                // 在RxJava 2.x 中，新增的Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
                mDisposable.dispose();
                mRxOperatorsText.append("onNext : isDisposable : " + mDisposable.isDisposed() + "\n");
                Log.e(TAG, "onNext : isDisposable : " + mDisposable.isDisposed() + "\n");
            }
        }

        @Override
        public void onError(@NonNull Throwable e) {
            mRxOperatorsText.append("onError : value : " + e.getMessage() + "\n");
            Log.e(TAG, "onError : value : " + e.getMessage() + "\n" );
        }

        @Override
        public void onComplete() {
            mRxOperatorsText.append("onComplete" + "\n");
            Log.e(TAG, "onComplete" + "\n" );
        }
    });
}

Zip操作符

 Observable.zip(getStringObservable(), getIntegerObservable(), new BiFunction<String, Integer, String>() {
            @Override
            public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
                return s + integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                mRxOperatorsText.append("zip : accept : " + s + "\n");
                Log.e(TAG, "zip : accept : " + s + "\n");
            }
        });

    }

  private Observable<String> getStringObservable() {
        return Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                if (!e.isDisposed()) {
                    e.onNext("A");
                    mRxOperatorsText.append("String emit : A \n");
                    Log.e(TAG, "String emit : A \n");
                    e.onNext("B");
                    mRxOperatorsText.append("String emit : B \n");
                    Log.e(TAG, "String emit : B \n");
                    e.onNext("C");
                    mRxOperatorsText.append("String emit : C \n");
                    Log.e(TAG, "String emit : C \n");
                }
            }
        });
    }

private Observable<Integer> getIntegerObservable() {
    return Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
            if (!e.isDisposed()) {
                e.onNext(1);
                mRxOperatorsText.append("Integer emit : 1 \n");
                Log.e(TAG, "Integer emit : 1 \n");
                e.onNext(2);
                mRxOperatorsText.append("Integer emit : 2 \n");
                Log.e(TAG, "Integer emit : 2 \n");
                e.onNext(3);
                mRxOperatorsText.append("Integer emit : 3 \n");
                Log.e(TAG, "Integer emit : 3 \n");
                e.onNext(4);
                mRxOperatorsText.append("Integer emit : 4 \n");
                Log.e(TAG, "Integer emit : 4 \n");
                e.onNext(5);
                mRxOperatorsText.append("Integer emit : 5 \n");
                Log.e(TAG, "Integer emit : 5 \n");
            }
        }
    });
}

输出结果

第二个发射器事件4，5被舍弃掉了，应证了上面对zip的解释。

map操作符

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
            //将int转String的函数
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(@NonNull Integer integer) throws Exception {
                return "This is result " + integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                mRxOperatorsText.append("accept : " + s +"\n");
                Log.e(TAG, "accept : " + s +"\n" );
            }
        });
    }

以上就是我对三个常见操作符的理解。希望对大家能有帮助。