一.基本使用
1.链式调用
首先在build.gradle中添加依赖:
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
implementation 'io.reactivex.rxjava2:rxjava:2.0.7'
RxJava的使用步骤包括:
- 创建被观察者进行事件发送
- 创建观察者进行事件响应
- 通过订阅方法连接观察者和被观察者
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(2);
e.onNext(3);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: "+e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: ");
}
});
被观察者通过ObservableEmitter的onNext进行事件发送,在观察者的onNext方法中进行事件接收。
2.onComplete
被观察者可以调用ObservableEmitter的onComplete方法通知观察者发送完成,此时观察者的onComplete方法中会收到该通知。之后,被观察者可以继续发送事件,但观察者不会再接收。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(2);
e.onComplete();
e.onNext(3);
Log.e(TAG, "被观察者-Emitter:3 已发送" );
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "观察者-onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "观察者-onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "观察者-onError: "+e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "观察者-onComplete: ");
}
});
输出:
2019-11-03 16:46:09.098 24226-24226/com.example.rxjava_learn E/MainActivity: 观察者-onSubscribe:
2019-11-03 16:46:09.099 24226-24226/com.example.rxjava_learn E/MainActivity: 观察者-onNext: 2
2019-11-03 16:46:09.099 24226-24226/com.example.rxjava_learn E/MainActivity: 观察者-onComplete:
2019-11-03 16:46:09.099 24226-24226/com.example.rxjava_learn E/MainActivity: 被观察者-Emitter:3 已发送
3.onError
被观察者可以调用ObservableEmitter的onError方法发送异常,此时观察者的onError方法中会收到该异常。被观察者在发送异常之后再使用onNext发送事件,观察者不会收到事件。如果被观察者在发送完onComplete之后发送onError会导致程序崩溃。
4.Disposable
当被观察者执行subscribe方法连接观察者时,在观察者的onSubscribe方法中可以得到Disposable对象,通过调用该对象的dispose方法可以断开被观察者和观察者之间的连接,断开之后,被观察者可以继续发送事件,但观察者无法接受。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
for (int i=0;i<3;i++){
e.onNext(i);
Log.e(TAG, "被观察者发送:" + i );
}
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "观察者-onSubscribe: ");
disposable = d;
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "观察者-onNext: " + integer);
disposable.dispose();
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "观察者-onError: "+e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "观察者-onComplete: ");
}
});
输出:
2019-11-03 16:54:15.341 24927-24927/com.example.rxjava_learn E/MainActivity: 观察者-onSubscribe:
2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 观察者-onNext: 0
2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 被观察者发送:0
2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 被观察者发送:1
2019-11-03 16:54:15.343 24927-24927/com.example.rxjava_learn E/MainActivity: 被观察者发送:2
dispose方法可以放在Activity的onDestroy中,在应用退出时执行。
@Override
protected void onDestroy() {
super.onDestroy();
if (disposable != null){
disposable.dispose();
}
}
二.操作符
RxJava中,主要用到的操作符有创建型操作符、过滤型操作符、合并型操作符、变换型操作符、条件型操作符以及异常处理操作符。
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/bce9952ca6651a29c8b936c2f6e2708b.png)
(一)创建型操作符
创建型操作符用于创建被观察者,向观察者发送事件,主要有以下几种:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/450b1ec90932b2ea390adf20b44ec431.png)
1.just
just方法中可以输入任意数量的参数(最多10个),被观察者会依次将这些参数发送给观察者。
Observable.just(1,"3",1.0f)
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: ");
}
@Override
public void onNext(Object o) {
Log.e(TAG, "onNext: " + o );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: ");
}
});
输出:
2019-11-03 21:19:33.481 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe:
2019-11-03 21:19:33.481 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1
2019-11-03 21:19:33.482 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 3
2019-11-03 21:19:33.483 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1.0
2019-11-03 21:19:33.484 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:
2.fromArray
fromArray接收一个数组,并把数组元素依次进行发送。
Integer[] arr = new Integer[]{1,2,3};
Observable.fromArray(arr)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-03 21:21:24.796 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe:
2019-11-03 21:21:24.796 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1
2019-11-03 21:21:24.796 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 2
2019-11-03 21:21:24.797 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 3
2019-11-03 21:21:24.797 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:
3.empty
empty会发送只会发送onComplete事件,观察者的泛型只能是Object。
Observable.empty()
.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Object o) {
Log.e(TAG, "onNext: " );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-03 21:21:49.201 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe:
2019-11-03 21:21:49.201 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:
4.range
range接收两个int型参数,第一个参数是起始值,第二个参数是数量。
Observable.range(1,3)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-03 21:25:28.565 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe:
2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 1
2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 2
2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 3
2019-11-03 21:25:28.566 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:
5.defer
defer用于动态创建被观察者,只有观察者订阅时,被观察者才会被创建。
i = 1;
Observable<Object> observable = Observable.defer(new Callable<ObservableSource<?>>() {
@Override
public ObservableSource<?> call() throws Exception {
return Observable.range(i, 3);
}
});
i = 10;
observable.subscribe(new Observer<Object>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Object o) {
Log.e(TAG, "onNext: " + o);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onSubscribe:
2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 10
2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 11
2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onNext: 12
2019-11-03 21:27:44.967 31925-31925/com.example.rxjava_learn E/MainActivity: onComplete:
6.timer
timer可以设置延时时间,延时时间过后,发送一个0.
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Long aLong) {
Log.e(TAG, "onNext: " + aLong);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/632dd14224cd3265f97913f50bd21413.gif)
7.interval
interval用于每隔指定时间发送事件,事件是从0开始递增1的序列。第一个参数是第一次延迟时间,第二个参数是时间间隔,第三个参数是时间单位。
Observable.interval(3,1,TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Long aLong) {
Log.e(TAG, "onNext: " + aLong );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/6b9f231722786d88274e4d418acba28b.gif)
8.intervalRange
intervalRange在interval基础上增加了两个参数,第一个参数表示发送整数序列的起始值,第二个参数表示整数序列的数量。
Observable.intervalRange(10,5,3,1,TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: " );
}
@Override
public void onNext(Long aLong) {
Log.e(TAG, "onNext: " + aLong );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/a1971e8070a7846cc9683a3ce2997ee6.gif)
(二)变换型操作符
变换型操作符用在被观察者发送事件之后、观察者接收事件之前,对发送的事件进行变换操作。
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/9da9205b8204d3fd4f4a18f1339d9a3e.png)
1.map
map对发送的事件进行处理,变换成另一种事件。
Observable.just(1,2,3)
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "map变换之后:" + integer;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: " + s );
}
});
输出:
2019-11-05 23:28:58.075 8343-8343/com.example.rxjava_learn E/TransActivity: accept: map变换之后:1
2019-11-05 23:28:58.075 8343-8343/com.example.rxjava_learn E/TransActivity: accept: map变换之后:2
2019-11-05 23:28:58.075 8343-8343/com.example.rxjava_learn E/TransActivity: accept: map变换之后:3
2.flatMap
flatMap接收观察者发送的事件,返回值类型为ObservableSource(被观察者),即把接收到的事件进行了第二次发送。flatMap进行二次发送时是没有顺序的。
Observable.just("A","B","C")
.flatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
List<String> list = new ArrayList<>();
for (int i=1;i<=3;i++){
list.add("事件" + s + "的子事件" + i);
}
return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String o) throws Exception {
Log.e(TAG, "accept: " + o );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/606b546fda9a16650f4708221c2577fb.png)
3.concatMap
concatMap与flatMap功能类似,区别是concatMap进行二次发送的事件是有序的。
Observable.just("A","B","C")
.concatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
List<String> list = new ArrayList<>();
for (int i=1;i<=3;i++){
list.add("事件" + s + "的子事件" + i);
}
return Observable.fromIterable(list).delay(5, TimeUnit.SECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String o) throws Exception {
Log.e(TAG, "accept: " + o );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/b0edea96f2779ee2c703afb5cf4051ea.png)
4.groupBy
groupBy用于对发送的事件进行分组,groupBy为分组的逻辑,在观察者中的groupedObservable对象中,groupedObservable的getKey方法可以得到组名称。
Observable.just(81,92,63,94,73,99,90)
.groupBy(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return integer >= 90 ? "优" : "良";
}
}).subscribe(new Consumer<GroupedObservable<String, Integer>>() {
@Override
public void accept(GroupedObservable<String, Integer> groupedObservable) throws Exception {
groupedObservable.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, groupedObservable.getKey() + ": " + integer );
}
});
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/fe899d0c4863ec62e7335819594c67f7.png)
5.buffer
buffer从被观察者中获取一定数量的事件放入缓冲区,然后发送给观察者,第一个参数为缓冲区大小,第二个参数为每次获取新事件的数量。
Observable.just(1,2,3,4,5,6,7,8,9,10)
.buffer(3,2)
.subscribe(new Consumer<List<Integer>>() {
@Override
public void accept(List<Integer> integers) throws Exception {
Log.e(TAG, "accept: " + integers );
Log.e(TAG, "---------------" );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/39dded83744b1c562bdbefe4802d4d54.png)
(三)过滤型操作符
过滤型操作符可以设置过滤条件,对发送的事件进行过滤。
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/e975b63789daaea1bb9385bd2e55b3af.png)
1.filter
filter中可以指定过滤条件,filter内返回值为true代表不过滤事件,返回false代表过滤事件。
Observable.just(1,2,3,4,5)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer > 3 ? true : false;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
输出:
2019-11-05 23:57:13.977 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 4
2019-11-05 23:57:13.978 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 5
2.take
take用在定时器中,参数为整数,表示取一定数量的事件,超过该数量的事件过滤掉。
Observable.interval(1, TimeUnit.SECONDS)
.take(5)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "accept: " + aLong );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/a87933a790f7f38e6586fc4713ad3120.gif)
3.distinct
distinct用于过滤掉重复事件。
Observable.just(1,1,1,2,2,3,3)
.distinct()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
输出:
2019-11-06 00:01:31.338 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 1
2019-11-06 00:01:31.338 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 2
2019-11-06 00:01:31.338 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: 3
4.elementAt
elementAt指定获取某个事件,如果获取不到,则获取默认事件。
Observable.just("A","B","C")
.elementAt(1,"D")
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: " + s );
}
});
输出:
2019-11-06 00:03:27.354 9482-9482/com.example.rxjava_learn E/FilterActivity: accept: B
(四)条件型操作符
条件型操作符主要用于判断发送的事件是否满足设定的条件。
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/2f49c8c0e51ae33c35c742db51ee23ad.png)
1.all
all用来判断发送的所有事件是否同时满足某条件,如果满足,返回true。
Observable.just(1,2,3,4)
.all(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer > 0;
}
})
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.e(TAG, "accept: " + aBoolean);
}
});
输出:
2019-11-06 19:54:16.950 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: true
2.contains
contains用来判断发送的事件中是否包含某个事件。
Observable.just("A","B","C")
.contains("D")
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.e(TAG, "accept: " + aBoolean);
}
});
输出:
2019-11-06 19:55:18.179 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: false
3.isEmpty
isEmpty用来判断发送的事件是否为empty。
Observable.empty()
.isEmpty()
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.e(TAG, "accept: " + aBoolean );
}
});
输出:
2019-11-06 19:56:50.480 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: true
4.any
any用来判断发送的所有事件中是否至少有一个事件满足条件。
Observable.just(1,2,3,4)
.any(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer > 3;
}
})
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.e(TAG, "accept: " + aBoolean);
}
});
输出:
2019-11-06 19:58:00.370 10315-10315/com.example.rxjava_learn E/ConditionActivity: accept: true
(五)合并型操作符
合并型操作符用于合并多个被观察者发送的事件。
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/c852753cf0cde307105f08cfa0e927e9.png)
1.concat/concatArray
concat用于将多个被观察者组合在一起发送事件,组合后按照发送事件的顺序串行发送事件。concat最多组合4个被观察者,concatArray可以组合4个以上观察者。
Observable.concat(Observable.just(1,2),
Observable.just(3,4),
Observable.just(5,6))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
输出:
2019-11-06 20:13:47.051 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 1
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 2
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 3
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 4
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 5
2019-11-06 20:13:47.052 11365-11365/com.example.rxjava_learn E/CombineActivity: accept: 6
2.merge/mergeArray
concat用于将多个被观察者组合在一起发送事件,与concat的区别是merge组合后按照发送时间顺序发送事件。merge最多组合4个被观察者,mergeArray可以组合4个以上观察者。
Observable.merge(Observable.intervalRange(1,3,1,1, TimeUnit.SECONDS),
Observable.intervalRange(5,3,1,1, TimeUnit.SECONDS))
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(TAG, "accept: " + aLong );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/3a2748e52899e115ab19a1518a6da800.gif)
3.zip
zip按照多个被观察者的事件序列进行合并,即所有被观察者的第一个事件合并在一起,第二个事件合并在一起,最终合并得到的事件数量是事件最少的被观察者发送的事件数量。
Observable.zip(Observable.intervalRange(1, 6,1 ,1,TimeUnit.SECONDS),
Observable.just("A", "B", "C"), new BiFunction<Long, String, String>() {
@Override
public String apply(Long integer, String s) throws Exception {
return integer + "-" + s;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: " + s );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/5e03084627fd9f9156ffbc694dd291a0.gif)
4.combineLatest
combineLatest将处在同一时间点上的事件进行合并。
Observable.combineLatest(Observable.intervalRange(1, 6,1 ,1,TimeUnit.SECONDS),
Observable.just("A", "B", "C"), new BiFunction<Long, String, String>() {
@Override
public String apply(Long integer, String s) throws Exception {
return integer + "-" + s;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(TAG, "accept: " + s );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/3973880fdd5e7d93c72530f20659f599.gif)
5.reduce
reduce把被观察者发送的多个事件合并成一个事件发送。
Observable.just(1,2,3,4)
.reduce(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
输出:
2019-11-06 20:39:03.764 12906-12906/com.example.rxjava_learn E/CombineActivity: accept: 10
6.collect
collect用于将发送的多个事件收集到集合中。
Observable.just(1,2,3,4)
.collect(new Callable<ArrayList<Integer>>() {
@Override
public ArrayList<Integer> call() throws Exception {
return new ArrayList<>();
}
}, new BiConsumer<ArrayList<Integer>, Integer>() {
@Override
public void accept(ArrayList<Integer> integers, Integer integer) throws Exception {
integers.add(integer);
}
}).subscribe(new Consumer<ArrayList<Integer>>() {
@Override
public void accept(ArrayList<Integer> integers) throws Exception {
Log.e(TAG, "accept: " + integers );
}
});
输出:
2019-11-06 20:42:47.150 13113-13113/com.example.rxjava_learn E/CombineActivity: accept: [1, 2, 3, 4]
7.startWith/startWithArray
startWith用于在被观察者发送事件之前在开头添加一些事件,startWith每次添加一个事件,startWithArray可以一次添加多个事件。
Observable.just(4,5,6)
.startWith(3)
.startWithArray(1,2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(TAG, "accept: " + integer );
}
});
输出:
2019-11-06 20:45:36.801 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 1
2019-11-06 20:45:36.801 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 2
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 3
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 4
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 5
2019-11-06 20:45:36.802 13293-13293/com.example.rxjava_learn E/CombineActivity: accept: 6
(六)异常处理操作符
异常处理操作符用于对异常进行处理。
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/bd5f27523efb630f38ecae0ebe5afa0d.png)
1.onErrorReturn
onErrorReturn对被观察者发送到onError事件进行处理,观察者会在onNext只能够接收到处理结果。onErrorReturn接收到异常后,会中断被观察者的事件发送。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
for (int i=0;i<5;i++){
if (i == 3){
e.onError(new IllegalArgumentException("发送异常!"));
}
e.onNext(i);
}
}
}).onErrorReturn(new Function<Throwable, Integer>() {
@Override
public Integer apply(Throwable throwable) throws Exception {
Log.e(TAG, "onErrorReturn: " + "处理异常");
return 404;
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 0
2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 1
2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 2
2019-11-06 22:32:28.917 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onErrorReturn: 处理异常
2019-11-06 22:32:28.918 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onNext: 404
2019-11-06 22:32:28.918 17394-17394/com.example.rxjava_learn E/ExceptionActivity: onComplete:
2.onErrorResumeNext
onErrorResumeNext返回值为被观察者,在返回的被观察者中可以再次发送多个事件。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
for (int i=0;i<5;i++){
if (i == 3){
e.onError(new IllegalArgumentException("发送异常!"));
}
e.onNext(i);
}
}
}).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {
return Observable.just(404);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-06 22:35:43.686 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 0
2019-11-06 22:35:43.686 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 1
2019-11-06 22:35:43.686 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 2
2019-11-06 22:35:43.687 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onNext: 404
2019-11-06 22:35:43.687 17593-17593/com.example.rxjava_learn E/ExceptionActivity: onComplete:
3.onExceptionResumeNext
onExceptionResumeNext可以处理通过throw抛出的异常,使程序不崩溃。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
for (int i=0;i<5;i++){
if (i == 3){
throw new IllegalArgumentException();
}
e.onNext(i);
}
}
}).onExceptionResumeNext(new ObservableSource<Integer>() {
@Override
public void subscribe(Observer<? super Integer> observer) {
observer.onNext(404);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 0
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 1
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 2
2019-11-06 22:51:02.833 18386-18386/com.example.rxjava_learn E/ExceptionActivity: onNext: 404
4.retry
被观察者发送onError事件后,retry可以进行重试操作。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
for (int i=0;i<5;i++){
if (i == 3){
e.onError(new IllegalArgumentException("发送异常!"));
}
e.onNext(i);
}
}
}).retry(2).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.e(TAG, "onNext: " + integer );
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.getMessage() );
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete: " );
}
});
输出:
![在这里插入图片描述](https://i-blog.csdnimg.cn/blog_migrate/3939ca6c88cd8eada357a3fd4bf338f7.png)