RxJava2对比RxJava1的一点区别：
1、RxJava2.x不支持传入null值，会报空指针异常。Observable
2、RxJava2.x中的Observable不支持背压，将用一个全新的flowable来支持背压。
背压是指在异步场景，被观察者发送事件的速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。
3、RxJava2.x已经没有Schedulers.immediate().
4、RxJava1.x有Func1、Func2....FuncN，但是RxJava2.x将它们移除，采用Function代替Func1，而采用BiFunction代替Func2...N.并且都增加了throw Exception。其中Action1和Action2用Consumer和BiConsumer替换，只保留了ActionN。
线程的类型
Schedulers.computation()：用于计算任务，默认线程数等于处理器的数量。
Schedulers.from(Executor executor):使用Executor作为调度器。
Schedulers.io() ：用于io密集型任务，例如访问网络、数据库等操作。
Schedulers.newThread() : 为每一个任务创建一个新的线程。
Schedulers.trampoline（）:当其他排队的任务完成后，在当前线程排队开始执行。
Schedulers.single（）:所有任务共用一个后台线程。
observeOn(AndroidSchedulers.mainThread())
Scheduler的原理
1.Schedulers.newThread() Schedulers.io();
· 当scheduleDirect()被调用时候,会创建一个 Worker,Worker的内部会有一个Excutor,由Executor来完成实际的线程切换;
· scheduleDirect() 还会创建出一个Disposable对象,交给外层的Observer,让它执行dispose()操作,取消订阅链;
· newThread()和io()的区别在于,io()可能会对Excutor进行重用.
2.AndroidSechedulers.mainThread();
通过内部的Handler把任务post到主线程去做
操作符
创建操作符、转换操作符、合并操作符、过滤操作符、其他操作符、条件操作符.
create
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter 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() {
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" );
}
});
需要注意的几点：在调用e.onComplete()，虽然无法接收事件，但是发送事件还是继续的。isDisposed（）可以切断事件的接收。
fromIterable
传入数组并按角标一次发送事件。
Observable.romIterable(list); //每次接收单个元素
fromArray
传入数组一次性发送，一次接收所有元素。
intervalRange
给事件更多的时间控制：
intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
参数1：起始发送值
参数2：发送数量
参数3：首次发送延迟事件
参数4：每次发送事件间隔
参数5：时间单位
Range
依次发送范围内的事件
Observable.range(2, 6)，接收类型Integer
Map
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "This is result " + integer;
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("accept : " + s +"\n");
Log.e(TAG, "accept : " + s +"\n" );
}
});
map基本作用就是将一个Observable通过某种函数关系转换为另一种Observable，上面例子是将Integer数据变成String类型。
Zip
专用于合并事件，该合并不是连接，而是两两配对，意味着最终配对输出的Observable发射事件数目只和少的那个相同。
Observable.zip(getStringObservable(), getIntegerObservable(), new BiFunction() {
@Override
public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
return s + integer;
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("zip : accept : " + s + "\n");
Log.e(TAG, "zip : accept : " + s + "\n");
}
});
private Observable getStringObservable() {
return Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter 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 getIntegerObservable() {
return Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter 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");
}
}
});
}
1.png
需要注意：zip组合事件是分别从发射器A和发射器B各取一个事件来组合，并且一个事件只能被使用一次，组合顺序严格按照事件发送来进行。
Concat
Observable.concat(Observable.just(1,2,3), Observable.just(4,5,6))
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("concat : "+ integer + "\n");
Log.e(TAG, "concat : "+ integer + "\n" );
}
});
输出的结果是：1 2 3 4 5 6
FlatMap
可以把一个发射器Observable通过某种方法转换为多个Observables，然后再把这些分散的Observables装进一个单一的发射器Observable。但这个不能保证事件的顺序，如果需要保证顺序可以用ConcatMap
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).flatMap(new Function>() {
@Override
public ObservableSource apply(@NonNull Integer integer) throws Exception {
List 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() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.e(TAG, "flatMap : accept : " + s + "\n");
mRxOperatorsText.append("flatMap : accept : " + s + "\n");
}
});
输出结果：
2.png
concatMap
唯一的区别就是保证顺序。
distinct
去除重复。
Observable.just(1, 1, 1, 2, 2, 3, 4, 5)
.distinct()
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("distinct : " + integer + "\n");
Log.e(TAG, "distinct : " + integer + "\n");
}
});
输出结果：1 2 3 4 5
Filter
过滤器，接受一个参数，让其过滤掉不符合条件的值
Observable.just(1, 20, 65, -5, 7, 19)
.filter(new Predicate() {
@Override
public boolean test(@NonNull Integer integer) throws Exception {
return integer >= 10;
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("filter : " + integer + "\n");
Log.e(TAG, "filter : " + integer + "\n");
}
});
输出结果： 20 65 19
buffer
接受两个参数，buffer（count，skip），作用是将Observable中数据按skip分成最大不超过count的buffer，然后生成一个Observable。
Observable.just(1, 2, 3, 4, 5)
.buffer(3, 2)
.subscribe(new Consumer>() {
@Override
public void accept(@NonNull List 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");
}
});
输出结果：
3.png
依次输出是123， 345， 5
timer
相当于一个定时任务，默认在新线程。
mRxOperatorsText.append("timer start : " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "timer start : " + TimeUtil.getNowStrTime() + "\n");
Observable.timer(2, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()) // timer 默认在新线程，所以需要切换回主线程
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
mRxOperatorsText.append("timer :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "timer :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
}
});
输出时间为间隔2S.可以用于防止多次点击按钮触发。
interval
用于间隔时间执行某个操作，接受三个参数，分别是第一次发送延迟，间隔时间，时间单位。
mRxOperatorsText.append("interval start : " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "interval start : " + TimeUtil.getNowStrTime() + "\n");
Observable.interval(3,2, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()) // 由于interval默认在新线程，所以我们应该切回主线程
.subscribe(new Consumer() {
@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");
}
});
输出结果：第一次延迟3S接收，后面每隔2s间隔。
由于是间隔执行，所以当我们的Activity销毁，实际这个操作符依然在进行，可以使用Disposable关闭。
@Override
protected void doSomething() {
mRxOperatorsText.append("interval start : " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "interval start : " + TimeUtil.getNowStrTime() + "\n");
mDisposable = Observable.interval(3, 2, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()) // 由于interval默认在新线程，所以我们应该切回主线程
.subscribe(new Consumer() {
@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");
}
});
}
@Override
protected void onDestroy() {
super.onDestroy();
if (mDisposable != null && !mDisposable.isDisposed()) {
mDisposable.dispose();
}
}
doOnNext
让订阅者在接收到数据之前干点其他事情。
Observable.just(1, 2, 3, 4)
.doOnNext(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("doOnNext 保存 " + integer + "成功" + "\n");
Log.e(TAG, "doOnNext 保存 " + integer + "成功" + "\n");
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("doOnNext :" + integer + "\n");
Log.e(TAG, "doOnNext :" + integer + "\n");
}
});
在获取到数据之前先保存数据。
输出：
4.png
skip
接受一个long型参数count，代表跳过count数目开始接收。
Observable.just(1,2,3,4,5)
.skip(2)
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("skip : "+integer + "\n");
Log.e(TAG, "skip : "+integer + "\n");
}
});
输出结果： 3 4 5
take
接受一个long型参数count，代表至多接收count个数据。
Flowable.fromArray(1,2,3,4,5)
.take(2)
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("take : "+integer + "\n");
Log.e(TAG, "accept: take : "+integer + "\n" );
}
});
输出结果：1 2
just
一个简单的发射器依次调用onNext()方法，最后默认调用onComplete()。
Observable.just("1", "2", "3")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("accept : onNext : " + s + "\n");
Log.e(TAG,"accept : onNext : " + s + "\n" );
}
});
Single
只会接收一个参数，而SingleObserver只会调用onError()或者onSuccess().
Single.just(new Random().nextInt())
.subscribe(new SingleObserver() {
@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");
}
});
debounce
去除发送频率过快的项。
image.png
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(@NonNull ObservableEmitter 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() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("debounce :" + integer + "\n");
Log.e(TAG,"debounce :" + integer + "\n");
}
});
输出结果： 2 4 5
defer
每次订阅都会创建一个新的Observable，并且如果没有被订阅，就不会产生新的Observable。
Observable observable = Observable.defer(new Callable>() {
@Override
public ObservableSource call() throws Exception {
return Observable.just(1, 2, 3);
}
});
observable.subscribe(new Observer() {
@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");
}
});
输出结果：1 2 3
last
仅取出可观察到的最后一个值，或者满足某些条件的最后一项。
Observable.just(1, 2, 3)
.last(4)
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("last : " + integer + "\n");
Log.e(TAG, "last : " + integer + "\n");
}
});
输出结果： 3
merge
把多个Observable结合起来，接受可变参数，也支持迭代器集合。是无序的。
Observable.merge(Observable.just(1, 2), Observable.just(3, 4, 5))
.subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("merge :" + integer + "\n");
Log.e(TAG, "accept: merge :" + integer + "\n" );
}
});
reduce
每次用一个方法处理一个值，可以有一个send作为初始值。
Observable.just(1, 2, 3)
.reduce(new BiFunction() {
@Override
public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("reduce : " + integer + "\n");
Log.e(TAG, "accept: reduce : " + integer + "\n");
}
});
输出结果：6
1+2 = 3+3 = 6
scan
和reduce一致，唯一的区别是reduce是只追求结果，而scan会把每一步都输出。
Observable.just(1, 2, 3)
.scan(new BiFunction() {
@Override
public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("scan " + integer + "\n");
Log.e(TAG, "accept: scan " + integer + "\n");
}
});
输出结果：1 3 6
window
按照实际划分窗口，将数据发送给不同的Observable
mRxOperatorsText.append("window\n");
Log.e(TAG, "window\n");
Observable.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次
.take(15) // 最多接收15个
.window(3, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer>() {
@Override
public void accept(@NonNull Observable 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() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
mRxOperatorsText.append("Next:" + aLong + "\n");
Log.e(TAG, "Next:" + aLong + "\n");
}
});
}
});
输出结果：
5.png