1.前言
在很久之前就一直想整理一下rxjava，但是一直沒有時間，最近是因為離職了，總算有時間整理一下了。因為打算每篇部落格都記錄一個框架。所以為了描述清楚，本篇部落格可能略長（包含rxjava的簡介，使用，背壓，原理等），希望你們能認真的讀完，收穫肯定還是有的，也會採用大量的圖來介紹，這樣可以加深理解。也可以當一個工具部落格，需要的使用的話隨時查閱。
後續還會繼續出背壓和原理篇，敬請期待
2.簡介
什麼是rxjava？ 是一種事件驅動的基於非同步資料流的程式設計模式，整個資料流就像一條河流，它可以被觀測（監聽），過濾，操控或者與其他資料流合併為一條新的資料流。
三要素
- 被觀察者（Observable）
- 觀察者（Observer）
- 訂閱（subscribe）
好了，因為秉持著要有圖的思想，在介紹rxjava各個操作符的時候，會採用大量的圖示來表示，圖示來源於官方，這裡先給大家介紹一下怎麼看。
ok，進入到擼碼環節
3.簡單使用
1.首先要在 build.gradle 檔案中新增依賴
implementation 'io.reactivex.rxjava2:rxjava:2.1.4'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
複製程式碼2.依賴搭建完畢了，我們先寫個最簡單的案例，一共3步走
- 2.1 建立被觀察者
// 建立被觀察者
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("你好呀");
emitter.onNext("我愛中國");
emitter.onNext("祝願祖國繁榮富強");
emitter.onComplete();
}
});
複製程式碼- 2.2 建立觀察者
// 建立觀察者
Observer observer = new Observer<String>(){
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
Log.i("lybj", "error");
}
@Override
public void onComplete() {
Log.i("lybj", "監聽完畢");
}
};
複製程式碼- 2.3 訂閱（也就是將被觀察者和觀察者關聯）
// 訂閱
observable.subscribe(observer);
複製程式碼這就完事了，看下結果
是不是很簡單，幾個概念再介紹一下
- onNext()：當被觀察者(observable)通過呼叫onNext()發射資料的時候，觀察者(observer)呼叫onNext()接收資料
- onError()：當被觀察者(observable)呼叫該函式時，觀察者(observer)呼叫onError()，其他事件將不會繼續傳送
- onComplete()：當被觀察者(observable)呼叫該函式時，觀察者(observer)呼叫onComplete()，其他事件將不會繼續傳送
其實rxjava，打個比方，就類似花灑的頭，資料流就類似水流，它的被觀察者（observable）的各種操作符就是花灑的那個頭，可以有各種模式，比如中間噴水的，周圍噴水的，噴水霧的等等。根據操作符的不同，可以改變資料的各種樣式，根據花灑頭的不同，可以把水流改成各種樣式。 接下來，就來學習下observable的豐富的操作符。
先看看大綱
4.建立操作符
1.create()
1.1 做啥的？
建立被觀察者物件
1.2 如何用?
// 建立被觀察者
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("你好呀");
emitter.onNext("我愛中國");
emitter.onNext("祝願祖國繁榮富強");
emitter.onComplete();
}
}).subscribe(new Observer<String>(){ // 關聯觀察者
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
Log.i("lybj", "error");
}
@Override
public void onComplete() {
Log.i("lybj", "監聽完畢");
}
});
複製程式碼1.3 結果
可以直接鏈式呼叫關聯觀察者
2 just()
2.1 做啥的？
通過上面的圖，應該很形象的說明了，主要作用就是建立一個被觀察者，併傳送事件，但是傳送的事件不可以超過10個以上。
2.2 如何用?
Observable.just("小明", "小紅", "小蘭").subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(String s) {
Log.i("lybj", s+"來了");
}
@Override
public void onError(Throwable e) {
Log.i("lybj", "Error");
}
@Override
public void onComplete() {
Log.i("lybj", "完畢");
}
});
複製程式碼2.3 結果
3 timer()
3.1 做啥的？
當到指定時間後就會傳送一個 0 的值給觀察者。 在專案中，可以做一些延時的處理，類似於Handler中的延時
3.2 如何用?
Observable.timer(2, TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i("lybj", aLong+"");
}
});
複製程式碼3.3 結果
延遲2秒後，將結果傳送給觀察者，Consumer和Observer是建立觀察者的兩種寫法，相當於觀察者中的onNext方法。
4 interval()
4.1 做啥的？
每隔一段時間就會傳送一個事件，這個事件是從0開始，不斷增1的數字。 類似於專案中的timer，做計時器
4.2 如何用?
Observable.interval(3,TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i("lybj", aLong+"");
}
});
複製程式碼4.3 結果
5 intervalRange()
5.1 做啥的？
可以指定傳送事件的開始值和數量，其他與 interval() 的功能一樣。
5.2 如何用?
Observable.intervalRange(100, 4, 0, 10, TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i("lybj", aLong+"");
}
});
複製程式碼5.3 結果
引數依次是：開始值，迴圈執行的次數，初始延遲時間，執行間隔時間，時間單位
6 range()
6.1 做啥的？
同時傳送一定範圍的事件序列。
6.2 如何用?
Observable.range(0,10).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼6.3 結果
7 rangeLong()
7.1 做啥的？
作用與 range() 一樣，只是資料型別為 Long
7.2 如何用?
Observable.rangeLong(0,10).subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i("lybj", aLong+"");
}
});
複製程式碼7.3 結果
8 empty() & never() & error()
8.1 做啥的？
- never()：不傳送任何事件
- error()：傳送 onError() 事件
- empty() ： 直接傳送 onComplete() 事件
8.2 如何用?
private void empty_never_error(){
Observable.empty().subscribe(new Observer(){
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(Object o) {
Log.i("lybj", o+"");
}
@Override
public void onError(Throwable e) {
Log.i("lybj", "onError");
}
@Override
public void onComplete() {
Log.i("lybj", "onComplete");
}
});
複製程式碼8.3 結果
如果是empty() 則：
如果是error() 則：
如果是never()則：
5.轉換操作符
1 map()
1.1 做啥的？
map 可以將被觀察者傳送的資料型別轉變成其他的型別
1.2 怎麼用？
Observable.just("中國", "祖國", "中國軍人")
.map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return "我愛" + s;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i("lybj", s);
}
});
複製程式碼1.3 結果
簡單來講，就是可以對發射過來的資料進行再加工，再傳給觀察者
2 flatMap()
2.1 做啥的？
這個方法可以將事件序列中的元素進行整合加工，返回一個新的被觀察者。 flatMap() 其實與 map() 類似，但是 flatMap() 返回的是一個 Observerable，map()只是返回資料，如果在元素再加工的時候，想再使用上面的建立操作符的話，建議使用flatMap()，而非map()。
2.2 怎麼用？
Observable.just("中國", "祖國", "中國軍人", "貪官")
.flatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
if(s.equals("貪官")){
return Observable.error(new Exception("貪官不能被喜歡"));
}
return Observable.just("我愛"+s);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i("lybj", s);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.i("lybj", throwable.getMessage());
}
});
複製程式碼2.3 結果
new Consumer方法監聽的是Observable.error()
3 concatMap()
3.1 做啥的？
concatMap() 和 flatMap() 基本上是一樣的，只不過 concatMap() 轉發出來的事件是有序的，而 flatMap() 是無序的。
3.2 怎麼用？
Observable.just("中國", "祖國", "中國軍人", "貪官")
.concatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
if(s.equals("貪官")){
return Observable.error(new Exception("貪官不能被喜歡"));
}
return Observable.just("我愛"+s);
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i("lybj", s);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.i("lybj", throwable.getMessage());
}
});
複製程式碼3.3 結果
4 buffer()
4.1 做啥的？
從需要傳送的事件當中獲取一定數量的事件，並將這些事件放到緩衝區當中一併發出。
4.2 怎麼用？
buffer 有兩個引數，一個是 count，另一個 skip。count 緩衝區元素的數量，skip 就代表緩衝區滿了之後，傳送下一次事件序列的時候要跳過多少元素。
Observable.just("1", "2", "3", "4", "5")
.buffer(2,1)
.subscribe(new Consumer<List<String>>() {
@Override
public void accept(List<String> strings) throws Exception {
Log.d("lybj", "緩衝區大小： " + strings.size());
for (String s : strings){
Log.d("lybj", s);
}
}
});
複製程式碼4.3 結果
5 scan()
5.1 做啥的？
將發射的資料通過一個函式進行變換，然後將變換後的結果作為引數跟下一個發射的資料一起繼續通過那個函式變換，這樣依次連續發射得到最終結果。
5.2 怎麼用
Observable.just(1, 2, 3, 4, 5)
.scan(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.i("lybj", "integer01: " + integer + " integer02: "+ integer2);
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", "accept: " + integer);
}
});
複製程式碼5.3 結果
簡單來說，先將第一個元素返回給觀察者，然後將1，2的和返給觀察者，然後將上一次計算的和，當第一個元素，也就是3，第2個元素，是一直按順序取值，取第3個元素也就是3，那麼將，3+3 =6，返回給觀察者，以此類推，將6作為第一個元素，第二個元素取值4，將6+4=10返回給觀察者。
sacn操作符是遍歷源Observable產生的結果，再按照自定義規則進行運算，依次輸出每次計算後的結果給訂閱者
6 window()
6.1 做啥的？
傳送事件時，將這些事件分為按數量重新分組。window 中的 count 的引數就是代表指定的數量，例如將 count 指定為2，那麼每發2個資料就會將這2個資料分成一組。
window與buffer區別：window是把資料分割成了Observable，buffer是把資料分割成List
6.2 如何用？
Observable.just("魯班", "孫尚香", "亞索","火女","蓋倫")
.window(2)
.subscribe(new Consumer<Observable<String>>() {
@Override
public void accept(Observable<String> stringObservable) throws Exception {
Log.i("lybj", "分組開始");
stringObservable.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i("lybj", s);
}
});
}
});
複製程式碼6.3 結果
6.組合操作符
1.concat()
1.1 做啥的？
可以將多個觀察者組合在一起，然後按照之前傳送順序傳送事件。需要注意的是，concat() 最多隻可以傳送4個事件。
1.2 怎麼用？
private void concat(){
Observable.concat(
Observable.just(1, 2, 3),
Observable.just(4, 5),
Observable.just(6, 7),
Observable.just(8, 9))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
}
複製程式碼1.3 結果
2.concatArray()
2.1 做啥的？
與 concat() 作用一樣，不過 concatArray() 可以傳送多於 4 個被觀察者。
2.2 怎麼用？
Observable.concatArray(Observable.just(1, 2, 3, 4),
Observable.just(5, 6),
Observable.just(7, 8, 9, 10),
Observable.just(11, 12, 13),
Observable.just(14, 15),
Observable.just(16))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼2.3 結果
3.merge()
3.1 做啥的？
這個方法與 concat() 作用基本一樣，但是 concat() 是序列傳送事件，而 merge() 並行傳送事件，也是隻能傳送4個。
3.2 怎麼用？
Observable.merge(Observable.just(1, 2, 3, 4),
Observable.just(5, 6),
Observable.just(7, 8, 9, 10),
Observable.just(11, 12, 13))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼3.3 結果
4.zip()
4.1 做啥的？
zip操作符用於將多個資料來源合併，並生成一個新的資料來源。新生成的資料來源嚴格按照合併前的資料來源的資料發射順序，並且新資料來源的資料個數等於合併前發射資料個數最少的那個資料來源的資料個數。
4.2 怎麼用？
Observable.zip(Observable.just(1, 2, 3),
Observable.just("A", "B", "C", "D", "E"),
new BiFunction<Integer, String, String>(){
@Override
public String apply(Integer o1, String o2) throws Exception {
return o1 +"_"+ o2;
}
})
.subscribe(new Consumer<String>() {
@Override
public void accept(String o) throws Exception {
Log.i("lybj", o);
}
});
複製程式碼4.3 結果
5.startWith() & startWithArray()
5.1 做啥的？
在傳送事件之前追加事件，startWith() 追加一個事件，startWithArray() 可以追加多個事件。追加的事件會先發出。
5.2 怎麼用？
Observable.just(1, 2, 3)
.startWithArray(4, 5)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼5.3 結果
6.count()
6.1 做啥的？
返回被觀察者傳送事件的數量。
6.2 怎麼用？
Observable.just(2, 3, 4, 5, 6)
.count()
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i("lybj", "事件數量：" + aLong);
}
});
複製程式碼6.3 結果
7.功能操作符
1.delay()
1.1 做啥的？
延遲一段事件傳送事件。
1.2 怎麼用？
Observable.just(1,2,3,4)
.delay(3, TimeUnit.SECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼1.3 結果
2.周期函式
2.1 做啥的？
doOnEach(): 每次傳送事件之前都會回撥這個方法
doOnNext(): Observable 每傳送 onNext() 之前都會先回撥這個方法。
doAfterNext(): Observable 每傳送 onNext() 之後都會回撥這個方法。
doOnComplete(): Observable 每傳送 onComplete() 之前都會回撥這個方法。
doOnError(): Observable 每傳送 onError() 之前都會回撥這個方法。
doOnSubscribe(): Observable 每傳送 onSubscribe()之前都會回撥這個方法。
doOnDispose(): 當呼叫 Disposable 的 dispose() 之後回撥該方法。
doOnTerminate(): 在 onError 或者 onComplete 傳送之前回撥。
doAfterTerminate(): onError 或者 onComplete 傳送之後回撥。
doFinally(): 在所有事件傳送完畢之後回撥該方法。如果取消訂閱之後doAfterTerminate()就不會被回撥，而doFinally()無論怎麼樣都會被回撥，且都會在事件序列的最後。
2.2 怎麼用？
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doOnEach(new Consumer<Notification<Integer>>() {
@Override
public void accept(Notification<Integer> integerNotification) throws Exception {
Log.i("lybj", "doOnEach 方法執行了, 結果："+ integerNotification.getValue());
}
}).doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", "doOnNext 方法執行了, 結果："+ integer);
}
}).doAfterNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", "doAfterNext 方法執行了, 結果："+ integer);
}
}).doOnComplete(new Action() {
@Override
public void run() throws Exception {
Log.i("lybj", "doOnComplete 方法執行了");
}
}).doOnError(new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.i("lybj", "doOnError 方法執行了");
}
}).doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
Log.i("lybj", "doOnSubscribe 方法執行了");
}
}).doOnDispose(new Action() {
@Override
public void run() throws Exception {
Log.i("lybj", "doOnDispose 方法執行了");
}
}).doOnTerminate(new Action() {
@Override
public void run() throws Exception {
Log.i("lybj", "doOnTerminate 方法執行了");
}
}).doAfterTerminate(new Action() {
@Override
public void run() throws Exception {
Log.i("lybj", "doAfterTerminate 方法執行了");
}
}).doFinally(new Action() {
@Override
public void run() throws Exception {
Log.i("lybj", "doFinally 方法執行了");
}
}).subscribe(new Observer<Integer>() {
private Disposable disposable;
@Override
public void onSubscribe(Disposable d) {
disposable = d;
Log.i("lybj", "------觀察者onSubscribe()執行");
}
@Override
public void onNext(Integer integer) {
Log.i("lybj", "------觀察者onNext()執行："+integer);
if(integer == 2){
// disposable.dispose(); // 取消訂閱
}
}
@Override
public void onError(Throwable e) {
Log.i("lybj", "------觀察者onError()執行");
}
@Override
public void onComplete() {
Log.i("lybj", "------觀察者onComplete()執行");
}
});
複製程式碼2.3 結果
3.onErrorReturn()
3.1 做啥的？
當接受到一個 onError() 事件之後回撥，返回的值會回撥 onNext() 方法，並正常結束該事件序列。
3.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("小明：到");
emitter.onError(new IllegalStateException("error"));
emitter.onNext("小方：到");
}
}).onErrorReturn(new Function<Throwable, String>() {
@Override
public String apply(Throwable throwable) throws Exception {
Log.i("lybj", "小紅請假了");
return "小李：到";
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
Log.i("lybj", e.getMessage());
}
@Override
public void onComplete() {
}
});
複製程式碼3.3 結果
4.onErrorResumeNext()
4.1 做啥的？
當接收到 onError() 事件時，返回一個新的 Observable，並正常結束事件序列。
4.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("小明");
emitter.onNext("小方");
emitter.onNext("小紅");
emitter.onError(new NullPointerException("error"));
}
}).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends String>>() {
@Override
public ObservableSource<? extends String> apply(Throwable throwable) throws Exception {
return Observable.just("1", "2", "3");
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
Log.i("lybj", e.getMessage());
}
@Override
public void onComplete() {
Log.i("lybj", "onComplete");
}
});
複製程式碼4.3 結果
5.onExceptionResumeNext()
5.1 做啥的？
與 onErrorResumeNext() 作用基本一致，但是這個方法只能捕捉 Exception。
5.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("小明");
emitter.onNext("小方");
emitter.onNext("小紅");
emitter.onError(new Error("error"));
}
}).onExceptionResumeNext(new Observable<String>() {
@Override
protected void subscribeActual(Observer observer) {
observer.onNext("小張");
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
Log.i("lybj", e.getMessage());
}
@Override
public void onComplete() {
Log.i("lybj", "onComplete");
}
});
複製程式碼5.3 結果
6.retry()
6.1 做啥的？
如果出現錯誤事件，則會重新傳送所有事件序列。times 是代表重新發的次數。
6.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
emitter.onNext("2");
emitter.onError(new IllegalStateException());
}
}).retry(2)
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i("lybj", "準備監聽");
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
Log.i("lybj", e.getMessage());
}
@Override
public void onComplete() {
Log.i("lybj", "onComplete");
}
});
複製程式碼6.3 結果
7.retryUntil()
7.1 做啥的？
出現錯誤事件之後，可以通過此方法判斷是否繼續傳送事件。
7.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
public void subscribe(@NonNull ObservableEmitter<String> emitter){
emitter.onNext("1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onError(new NullPointerException("error"));
emitter.onNext("4");
emitter.onNext("5");
}
}).retryUntil(new BooleanSupplier() {
@Override
public boolean getAsBoolean() throws Exception {
Log.i("lybj", "getAsBoolean");
return true;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i("lybj", s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
複製程式碼7.3 結果
8.repeat()
8.1 做啥的？
重複傳送被觀察者的事件，times 為傳送次數。
8.2 怎麼用？
Observable.just(1,2,3)
.repeat(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼8.3 結果
9.subscribeOn() & observeOn()
9.1 做啥的？
subscribeOn(): 指定被觀察者的執行緒，如果多次呼叫此方法，只有第一次有效。 observeOn(): 指定觀察者的執行緒
9.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
public void subscribe(@NonNull ObservableEmitter<String> emitter){
emitter.onNext("1");
Log.i("lybj", Thread.currentThread().getName());
}
}).subscribeOn(Schedulers.io())
.observeOn(Schedulers.newThread())
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i("lybj", s);
Log.i("lybj", Thread.currentThread().getName());
}
});
複製程式碼9.3 結果
8.過濾操作符
1.filter()
1.1 做啥的？
如果返回 true 則會傳送事件，否則不會傳送
1.2 怎麼用？
Observable.just(1,2,3,4,5)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
if(integer > 4){
return true;
}
return false;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼1.3 結果
2.ofType()
2.1 做啥的？
可以過濾不符合該型別事件
2.2 怎麼用？
Observable.just(1, 2, 3, "小明", "小方")
.ofType(String.class)
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i("lybj", s+"");
}
});
複製程式碼2.3 結果
3.skip()
3.1 做啥的？
跳過正序某些事件，count 代表跳過事件的數量
3.2 怎麼用？
Observable.just(1,2,3,4,5,6,7)
.skip(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼3.3 結果
4.distinct()
4.1 做啥的？
過濾事件序列中的重複事件。
4.2 做啥的？
Observable.just(1,2,3,1,4,1,2)
.distinct()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼4.3 結果
5.distinctUntilChanged()
5.1 做啥的？
過濾掉連續重複的事件
5.2 做啥的？
Observable.just(1,2,3,3,1,5,6)
.distinctUntilChanged()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼5.3 結果
6.take()
6.1 做啥的？
控制觀察者接收的事件的數量。
6.2 怎麼用？
Observable.just(1,2,3,4,5,6)
.take(3)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼6.3 結果
7.debounce()
7.1 做啥的？
如果兩件事件傳送的時間間隔小於設定的時間間隔則前一件事件就不會傳送給觀察者。 簡單來說就是防抖動，比如按鈕控制快速點選等。
7.2 怎麼用？
Observable.just(1,2,3,4,5)
.map(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
Thread.sleep(900);
return integer;
}
})
.debounce(1,TimeUnit.SECONDS)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼7.3 結果
8.firstElement() && lastElement() && elementAt()
8.1 做啥的？
firstElement(): 取事件序列的第一個元素。
lastElement(): 取事件序列的最後一個元素。
elementAt(): 以指定取出事件序列中事件，但是輸入的 index 超出事件序列的總數的話就不會出現任何結果。
8.2 怎麼用？
Observable.just(1,2,3,4)
.firstElement()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼8.3 結果
9.條件操作符
1.all()
1.1 做啥的？
判斷事件序列是否全部滿足某個事件，如果都滿足則返回 true，反之則返回 false。
1.2 怎麼用？
Observable.just(1, 2, 3, 4, 5)
.all(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer <= 4;
}
}).subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i("lybj", aBoolean+"");
}
});
複製程式碼1.3 結果
2.takeWhile() & takeUntil()
2.1 做啥的？
takeWhile(): 從左邊開始，將滿足條件的元素取出來，直到遇到第一個不滿足條件的元素，則終止 takeUntil(): 從左邊開始，將滿足條件的元素取出來，直到遇到第一個滿足條件的元素，則終止 filter(): 是將所有滿足條件的資料都取出。
2.2 怎麼用？
Observable.just(1, 2, 3, 4, 5)
.takeWhile(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer < 3;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼2.3 結果
3.skipWhile
3.1 做啥的？
從左邊開始，根據條件跳過元素
3.2 怎麼用？
Observable.just(1,2,3,4,5,3,2,1,7)
.skipWhile(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer < 3;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i("lybj", integer+"");
}
});
複製程式碼3.3 結束
4.isEmpty() & defaultIfEmpty()
4.1 做啥的？
isEmpty(): 判斷事件序列是否為空。
defaultIfEmpty(): 如果觀察者只傳送一個 onComplete() 事件，則可以利用這個方法傳送一個值。
4.2 怎麼用？
Observable.create(new ObservableOnSubscribe<String>() {
public void subscribe(@NonNull ObservableEmitter<String> emitter){
emitter.onComplete();
}
}).isEmpty()
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i("lybj", aBoolean+"");
}
});
複製程式碼4.3 結果
5.contains()
5.1 做啥的？
判斷事件序列中是否含有某個元素，如果有則返回 true，如果沒有則返回 false。
5.2 怎麼用？
在Observable.just(1,2,3,4,5,6)
.contains(2)
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i("lybj", aBoolean+"");
}
});
複製程式碼5.3 結果
6.sequenceEqual()
6.1 做啥的？
判斷兩個 Observable 傳送的事件是否相同。
6.2 怎麼用？
Observable.sequenceEqual(Observable.just("小明", "小方", "小李"),
Observable.just("小明", "小方", "小李", "小張"))
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i("lybj", aBoolean+"");
}
});
複製程式碼