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