RxJava2.0 学习（1）—— 操作符总结

最新推荐文章于 2022-09-22 15:16:20 发布

翻滚吧章鱼

最新推荐文章于 2022-09-22 15:16:20 发布

阅读量333

点赞数

分类专栏： IT android

本文链接：https://blog.csdn.net/weixin_37558974/article/details/84306175

版权

android 同时被 2 个专栏收录

43 篇文章 0 订阅

订阅专栏

19 篇文章 0 订阅

订阅专栏

看了 nanchen 大神得 Rxjava2.0 demo 自己做下总结

demo地址

https://github.com/nanchen2251/RxJava2Examples

操作符分为以下几类

延迟操作符

创建类型	作用	备注	使用场景
基本创建	create()	创建一个完成的被观察者(Observable)	RxJava中创建被观察者最基本的操作符	1、完整&快速创建被观察者2、数组、集合遍历
快速创建	empty()	快速创建后只发送complete事件，直接通知完成
error()	快速创建后只发送error事件，直接通知异常
never()	快速创建后不发送任何事件
just()	快速创建后直接发送传入的事件	参数最多只能10个，即发送的事件最多10个
fromArray()	快速创建后直接发送传入的数组数据	参数为数组，子类型为任意类型，可10个以上
fromIterable()	快速创建后直接发送传入的集合List数据	参数为集合List，子类型为任意类型，可10个以上
延时创建	defer()	直到观察者Observer订阅被观察者Observable时，才动态创建被观察者&发送事件	通过Observable工厂方法创建被观察者，每次订阅后都会得到一个最新创建的被观察者Observable，确保里面的数据是最新的	1、定时操作2、周期性操作
timer()	快速创建被观察者，指定延时时间，发送一个数值为0的事件	延时指定时间后发送一个参数为0的事件，相当于onNext（0）
interval()	快速创建被观察者，每隔指定时间发送事件	发送事件序列，从0开始，无限递增1
intervalRange()	快速创建被观察者，每隔指定时间发送事件，可指定发送事件数	发送无限递增1的事件序列，可指定起始值大小和事件次数，可延时，类似interval()
range()	快速创建被观察者，连续发送一个时间序列，可指定范围	发送无限递增1的事件序列，可指定起始值大小和事件次数，不可延时，类似intervalRange()
rangeLong()	同上，区别在于数据参数为类型Long	同上

变换操作符

创建类型	作用	使用场景
map()	对Observable发送的每一个事件进行转换	数据类型、事件等需要转换
flatMap()	对Observable发送的整个个事件进行转换（无序）
concatMap()	对Observable发送的整个个事件进行转换（有序）
buffer()	从Observable的事件中获取事件放到缓存区再发送事件

组合操作符

创建类型	作用	备注	使用场景
concat()与concatArray()	组合多个被观察者发送数据，合并后按照顺序执行	区别：组合被观察者数量：concat()<=4,concatArray()无限制	合并数据源联合处理
Merge()与MergeArray()	组合多个被观察者发送数据，合并后按照时间顺序执行	区别：组合被观察者数量：Merge()<=4,MergeArray()无限制
concatDelayError()	将错误事件延迟到所以事件执行完后才执行错误事件
megreDelayError()
startWith()与startWithArray()	在一个被观察者发送数据前，追加发送一些数据	调用顺序：先追加的后调用，后追加的先调用

合并操作符

创建类型	作用	备注	使用场景
zip()	合并多个被观察者发送的事件，生成一个新的事件序列。	严格按照事件序列进行合并最后Observable的数据=多个Observable中数量最少的	合并数据源联合处理
combineLatest()	将两个Observable产生的结果进行合并，合并新的Observable发送给订阅者	当其中一个Observable发送数据，都与另一个Observable最后发送的数据结合，类似zip()，不同的是按照时间点合并
combineLatestDelayError()	将错误事件延迟到所以事件执行完后才执行错误事件
reduce()	把观察者需要发送的事件聚合成一个事件并且发送。	前两个被观察者聚合成新的被观察者，再与下一数据聚合，一次类推
collect()	将被观察者发送的数据放到一个容器中处理

do相关操作符

doOnNext()	执行onNext()事件前调用	在事件生命周期伴随事件回调执行其他的相关逻辑
doOnEach()	当Observable每发送一次数据就调用一次
doAfterNext()	执行onNext()事件后调用
doOnError()	发送错误事件时调用
doAfterTerminate()	无论是正常发送事件完毕/异常终止都回调
doOnSubscribe()	观察者订阅时回调
doOnComplete()	正常发送事件完毕后
doFinally()	最后执行

错误操作符

onErrorReturn()	Observable发生错误或异常时发送一个相同类型的特殊事件，并且终止事件发送。	遇到错误异常时的解决机制
onErrorResumeNext()	Observable发生错误或异常时产生新的Observable发送一个特殊事件，并且终止事件发送。
onExceptionResumeNext()	同上，不同点：这里只能拦截异常不能拦截错误
retry()	发生异常或错误时重试源Observable的请求
retryWhen()	同上，不同点：将错误异常传递给新的Observable通知源Observable
repeat()	重复源Observable发送事件（抛出异常错误不能重复发送）
repeatWhen()	在回调方法中创建新的Observable，通过新的observable是否重复订阅和发送事件。

过滤操作符

创建类型	作用	备注	使用场景
filter()	按照指定的条件(自定义)对被观察者发出的结果进行过滤，再提交给被观察者	在回调方法中实现规则过滤	需要过滤或者选择某一步操作
ofType()	根据指定的数据类型对被观察者发出的结果进行过滤，再提交给被观察者	参数传入对结果过滤的类型
elementAt()	将指定索引被观察者发出的事件提交给观察者，索引为0	参数传入索引
distinct()	去重，去掉被观察者产生的重复的结果，将不重复的提交给观察者
debounce()	只接收到倒计时时间外的被观察者发出的事件，每个事件发出时会重置倒计时时间。	参数传入每个事件的倒计时时间
first()	将被观察者产生的第一个结果提交给被观察者处理
last()	将被观察者产生的最后一个结果提交给观察者处理
skip()	跳过前n个被观察者产生的结果，将后面的提交给观察者处理	参数传入指定跳过的数量
take()	将前n个被观察者产生的结果提交给观察者处理，其他的不做处理	参数传入指定执行的数量

其他操作符

创建类型	作用	备注
groupBy()	对于源Observable(被观察者)产生的结果进行分组，形成一个类型为GroupedObservable的结果集，存在一个方法为getKey()，通过该方法获取结果集的key值	如果事件结果没有处理，那么take()处理一下，否则会内存泄漏
cast()	用于类型转换，将源Observable的源类型转为指定的.class	如果类型不正确则会抛出转换异常。
scan()	遍历源Observable产生的结果，依次每个结果按照指定的规则进行计算，计算后的结果作为下一项迭代的参数，每一次迭代项都会把计算结果输出给订阅者。	每次计算的结果用于下次计算
join()	把两个Observable产生的结果进行合并，合并结果组成一个新的Observable，可以控制每个Observable产生结果的生命周期，在每个结果的生命周期内，可以与另一个Observable产生的结果按照一定的规则进行合并	合并结果产生新的Observable
groupJoin()	类似上述，第三个参数不一致，返回新的Observable处理

1操作符 Create

（获取一个observable 被观察这对象）

时间传递和拦截

Disposable.isDisposed 返回 false 表示事件继续

        @Override
        public void onSubscribe(@NonNull Disposable d) { isDisposed 弃置事件返回 true
        }

e.onNext(4); 事件进行下一步并将下次使用的参数传入

mDisposable.dispose(); //弃置事件，做到切断上游事件

            @Override
        public void onNext(@NonNull Integer integer) {
            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");
            }
        }

2操作符 Zip

（合并事件专用，分别从两个上游事件中各取出一个组合一个事件只能被使用一次，顺序严格按照事件发送的顺序，最终下游事件收到的是和上游事件最少的数目相同（必须两两配对，多余的舍弃)）

apply 中将上游的时间结果合并；accept 中拿到合并结果。

ps：如果一个上游是3步二个上游是5步，那么二个上游的 4 5步会被舍弃。

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");
        }
    });

3 操作符 Map

（基本是RxJava 最简单的操作符了作用是对上游发送的每一个事件应用一个函数，使得每一个事件都按照指定的函数去变化）

每个map 对应一个 Function函数其泛型两个类型 1 传入类型 2 返回值类型

    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
            e.onNext(1);
            e.onNext(2);
            e.onNext(3);
        }
    }).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" );
        }
    });

4 操作符 flatMap （返回结果没有顺序）

（FlatMap将一个发送事件的上游Observable变换成多个发送事件的Observables，
然后将它们发射的时间合并后放进一个单独的Observable里）

在Function 的返回值泛型改为下一次请求的ObservableSource对象

Observable.fromIterable(list) 需要连续处理时

.observeOn(AndroidSchedulers.mainThread()) 改变线程

accept 一次或多次的结果在这里返回（没有顺序）。

Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
            e.onNext(1);
//                e.onNext(2);
//                e.onNext(3);
            }
        }).flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
                List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("I am value " + integer);
                }
                int delayTime = (int) (1 + Math.random() * 10);
                return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
            }
        }).subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(@NonNull String s) throws Exception {
                        Log.e(TAG, "flatMap : accept : " + s + "\n");
                        mRxOperatorsText.append("flatMap : accept : " + s + "\n");
                    }
                });

5 操作符 ConcatMap （有返回顺序）

（与 flatMap的区别就是会按照发送顺序，返回结果）

6操作符 doOnNext （感觉作用不大）

（让订阅者在接收到数据前干点事情的操作符）

在第一个 accept 方法中，上去做一些预备动作。

    Observable.just(1, 2, 3, 4)
            .doOnNext(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("doOnNext 保存 " + integer + "成功" + "\n");
                    Log.e(TAG, "doOnNext 保存 " + integer + "成功" + "\n");
                }
            }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            mRxOperatorsText.append("doOnNext :" + integer + "\n");
            Log.e(TAG, "doOnNext :" + integer + "\n");
            }
        });
    }

7操作符 filter

（过滤操作符，取正确的值）

定义条件过滤掉 just 中的选项

    Observable.just(1, 20, 65, -5, 7, 19)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(@NonNull Integer integer) throws Exception {
                    Log.e(TAG, "THIS : " + integer + "\n");

                    return integer >= 10;
                }
            }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            mRxOperatorsText.append("filter : " + integer + "\n");
            Log.e(TAG, "filter : " + integer + "\n");
        }
    });

8操作符 skip

（接受一个long型参数，代表跳过多少个数目的事件再开始接收）

skip（2）跳过前两个从3开始；

        ArrayList<Integer> integers = new ArrayList<>();
	        integers.add(1);
   		    integers.add(2);
			integers.add(3);
  		Observable.fromIterable(integers)
            .skip(2)
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("skip : "+integer + "\n");
                    Log.e(TAG, "skip : "+integer + "\n");
                }
            });

9操作符 take（和 skip 效果互补）

（用于指定订阅者最多收到多少数据）

        Flowable.fromArray(1,2,3,4,5)
            .take(2) //只能收到 1 2 
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("take : "+integer + "\n");
                    Log.e(TAG, "accept: take : "+integer + "\n" );
                }
            });

10操作符 timer（）

（在Rxjava中timer 操作符既可以延迟执行一段逻辑，也可以间隔执行一段逻辑
【注意】但在RxJava 2.x已经过时了，现在用interval操作符来间隔执行，详见RxIntervalActivity timer和interval都默认执行在一个新线程上。）

11操作符 interval （2.0中取代了 timer）

Observable.interval(3, 2, TimeUnit.SECONDS) //第一次执行3秒间隔2秒继续执行

    mDisposable = Observable.interval(3, 2, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread()) // 由于interval默认在新线程，所以我们应该切回主线程
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(@NonNull Long aLong) throws Exception {
                    mRxOperatorsText.append("interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
                    Log.e(TAG, "interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
                }
            });

12 just 操作符（与1.0没有区别）

（接受可变的参数数量）

        Observable.just("1", "2", "3")
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(@NonNull String s) throws Exception {
                    mRxOperatorsText.append("accept : onNext : " + s + "\n");
                    Log.e(TAG,"accept : onNext : " + s + "\n" );
                }
            });

13 操作符 single （感觉没卵用啊）

（只接受一个参数）

        Single.just(new Random().nextInt())
            .subscribe(new SingleObserver<Integer>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {

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

14 操作符 concat（）

（连接多个可变集合）

        Observable.concat(Observable.just(1,2,3), Observable.just(4,5,6),Observable.just(7,8,9))
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("concat : "+ integer + "\n");
                    Log.e(TAG, "concat : "+ integer + "\n" );
                }
            });

15 操作符 distinct (感觉用的场景比较少)

（去重操作符，其实就是简单的去重）

        Observable.just(1, 1, 1, 2, 2, 3, 4, 5)
            .distinct()
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("distinct : " + integer + "\n");
                    Log.e(TAG, "distinct : " + integer + "\n");
                }
            });

16 操作符 buffer（不常用，可以解决变态需求！）

（buffer(count, skip)` 从定义就差不多能看出作用了，将 observable 中的数据按 skip（步长）分成最长不超过 count 的 buffer，然后生成一个 observable）

每次请求3个，请求完了往后挪2个位置；

        Observable.just(1, 2, 3, 4, 5,6,7,8,9)
            .buffer(3, 2)
            .subscribe(new Consumer<List<Integer>>() {
                @Override
                public void accept(@NonNull List<Integer> integers) throws Exception {
                    mRxOperatorsText.append("buffer size : " + integers.size() + "\n");
                    Log.e(TAG, "buffer size : " + integers.size() + "\n");
                    mRxOperatorsText.append("buffer value : ");
                    Log.e(TAG, "buffer value : " );
                    for (Integer i : integers) {
                        mRxOperatorsText.append(i + "");
                        Log.e(TAG, i + "");
                    }
                    mRxOperatorsText.append("\n");
                    Log.e(TAG, "\n");
                }
            });

17 操作符 debounce

（过滤掉发射频率过快的数据项）

debounce(500, TimeUnit.MILLISECONDS) //过滤掉发射速度超过 500毫秒的

        Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Exception {
            // send events with simulated time wait
            emitter.onNext(1); // skip
            Thread.sleep(400);
            emitter.onNext(2); // deliver
            Thread.sleep(505);
            emitter.onNext(3); // skip
            Thread.sleep(100);
            emitter.onNext(4); // deliver
            Thread.sleep(605);
            emitter.onNext(5); // deliver
            Thread.sleep(510);
            emitter.onComplete();
        }
    }).debounce(500, TimeUnit.MILLISECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("debounce :" + integer + "\n");
                    Log.e(TAG,"debounce :" + integer + "\n");
                }
            });

18 操作符 defer （没明白有什么特别）

（简单的说就是每次订阅都会创建一个新的Observable，并且如果该Observable没有被订阅，就不会生成新的Observable）

        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<Integer>>() {
        @Override
        public ObservableSource<Integer> call() throws Exception {
            return Observable.just(1, 2, 3);
        }
    });

    observable.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {

        }
        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("defer : " + integer + "\n");
            Log.e(TAG, "defer : " + integer + "\n");
        }

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

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

19 操作符 last

（取出最后一个值，参数是没有值的时候的默认值）

        Observable.just(1, 2, 3)
            .last(4)
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("last : " + integer + "\n");
                    Log.e(TAG, "last : " + integer + "\n");
                }
            });

20 操作符 merge （感觉个concat 没区别）

（将多个Observable合起来，接受可变参数，也支持使用迭代器集合）

        Observable.concat(Observable.just(1,2,3), Observable.just(4,5,6),Observable.just(7,8,9))
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(@NonNull Integer integer) throws Exception {
                    mRxOperatorsText.append("concat : "+ integer + "\n");
                    Log.e(TAG, "concat : "+ integer + "\n" );
                }
            });

21 操作符 reduce

（一次只处理一个参数值，前一次处理的结果，作为参数，参与到下一次,可以有一个seed作为初始值）

        Observable.just(1, 2, 5,8,15)
            .reduce(7,new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                    return integer + integer2;
                }
            }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            mRxOperatorsText.append("reduce : " + integer + "\n");
            Log.e(TAG, "accept: reduce : " + integer + "\n");
        }
    });

22 操作符 scan

（和 reduce 差不多 reduce 只返回最终结果，scan 会将每一次的结果返回）

    Observable.just(1, 2, 3)
            .scan(new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                    return integer + integer2;
                }
            }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            mRxOperatorsText.append("scan " + integer + "\n");
            Log.e(TAG, "accept: scan " + integer + "\n");
        }
    });
}

23 操作符 window （）

（按照时间划分窗口，将数据发送给不同的Observable）

.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次

.take(15) // 最多接收15个

.window(5, TimeUnit.SECONDS) // 每隔5秒切换一个 observable

        Observable
			.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次
            .take(15) // 最多接收15个
            .window(5, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Observable<Long>>() {
                @Override
                public void accept(@NonNull Observable<Long> longObservable) throws Exception {
                    mRxOperatorsText.append("Sub Divide begin...\n");
                    Log.e(TAG, "Sub Divide begin...\n");
                    longObservable.subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe(new Consumer<Long>(){
                                @Override
                                public void accept(@NonNull Long aLong) throws Exception {
                                    mRxOperatorsText.append("Next:" + aLong + "\n");
                                    Log.e(TAG, "Next:" + aLong + "\n");
                                }
                            });
                }
            });

24 操作符 PublishSubject （）

（onNext() 会通知每个观察者，仅此而已）

（会通知所有，的订阅者 ‘ Observer ’ ）

        PublishSubject<Integer> publishSubject = PublishSubject.create();

    publishSubject.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("First onSubscribe :"+d.isDisposed()+"\n");
            Log.e(TAG, "First onSubscribe :"+d.isDisposed()+"\n");
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("First onNext value :"+integer + "\n");
            Log.e(TAG, "First onNext value :"+integer + "\n");
        }

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

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

    publishSubject.onNext(1);
    publishSubject.onNext(2);
    publishSubject.onNext(3);

    publishSubject.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("Second onSubscribe :"+d.isDisposed()+"\n");
            Log.e(TAG, "Second onSubscribe :"+d.isDisposed()+"\n");
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("Second onNext value :"+integer + "\n");
            Log.e(TAG, "Second onNext value :"+integer + "\n");
        }

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

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

    publishSubject.onNext(4);
    publishSubject.onNext(5);
    publishSubject.onComplete();

25 操作符 AsyncSubject（）

（在调用 onComplete() 之前，除了 subscribe() 其它的操作都会被缓存，在调用 onComplete() 之后只有最后一个 onNext() 会生效）

只有 next（5）执行了

        AsyncSubject<Integer> asyncSubject = AsyncSubject.create();

    asyncSubject.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("First onSubscribe :"+d.isDisposed()+"\n");
            Log.e(TAG, "First onSubscribe :"+d.isDisposed()+"\n");
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("First onNext value :"+integer + "\n");
            Log.e(TAG, "First onNext value :"+integer + "\n");
        }

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

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

    asyncSubject.onNext(1);
    asyncSubject.onNext(2);
    asyncSubject.onNext(3);

    asyncSubject.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("Second onSubscribe :"+d.isDisposed()+"\n");
            Log.e(TAG, "Second onSubscribe :"+d.isDisposed()+"\n");
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("Second onNext value :"+integer + "\n");
            Log.e(TAG, "Second onNext value :"+integer + "\n");
        }

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

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

    asyncSubject.onNext(4);
    asyncSubject.onNext(5);
    asyncSubject.onComplete();

26 操作符 BehaviorSubject（）

（BehaviorSubject 的最后一次 onNext() 操作会被缓存，然后在 subscribe() 后立刻推给新注册的 Observer）

会缓存 onNext(3) ，有新注册的Observer 立刻给他

        BehaviorSubject<Integer> behaviorSubject = BehaviorSubject.create();

    behaviorSubject.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("First onSubscribe :"+d.isDisposed()+"\n");
            Log.e(TAG, "First onSubscribe :"+d.isDisposed()+"\n");
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("First onNext value :"+integer + "\n");
            Log.e(TAG, "First onNext value :"+integer + "\n");
        }

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

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

    behaviorSubject.onNext(1);
    behaviorSubject.onNext(2);
    behaviorSubject.onNext(3);

    behaviorSubject.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            mRxOperatorsText.append("Second onSubscribe :"+d.isDisposed()+"\n");
            Log.e(TAG, "Second onSubscribe :"+d.isDisposed()+"\n");
        }

        @Override
        public void onNext(@NonNull Integer integer) {
            mRxOperatorsText.append("Second onNext value :"+integer + "\n");
            Log.e(TAG, "Second onNext value :"+integer + "\n");
        }

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

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

    behaviorSubject.onNext(4);
    behaviorSubject.onNext(5);
    behaviorSubject.onComplete();
}

27 操作符 Completable（）

（只关心结果，也就是说 Completable 是没有 onNext 的，要么成功要么出错，不关心过程，在 subscribe 后的某个时间点返回结果）

        Completable.timer(1, TimeUnit.SECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new CompletableObserver() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {
                    mRxOperatorsText.append("onSubscribe : d :" + d.isDisposed() + "\n");
                    Log.e(TAG, "onSubscribe : d :" + d.isDisposed() + "\n");
                }

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

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

28 操作符 Flowable（待压力测试）

(专用于解决被压问题)

ps：“被压” 大概就是指在异步场景中，被观察者发送事件的速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略

        Flowable.just(1,2,3,4)
            .reduce(100, new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                    return integer+integer2;
                }
            }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(@NonNull Integer integer) throws Exception {
            mRxOperatorsText.append("Flowable :"+integer+"\n");
            Log.e(TAG, "Flowable :"+integer+"\n" );
        }
    });
}

后面会继续，整理 RxJava 2.0 相关内容

翻滚吧章鱼

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava2.0 学习（1）—— 操作符总结

RxJava2.0 学习（1）----操作符总结 2018年看了 nanchen 大神得 Rxjava2.0 demo 自己做下总结demo地址https://github.com/nanchen2251/RxJava2Examples1操作符 Create（获取一个observable 被观察这对象）时间传递和拦截Disposable.isDisposed 返回 false ...
复制链接

扫一扫