創建操作
以下操作符用於創建Observable。
create: 使用OnSubscribe從頭創建一個Observable,這種方法比較簡單。需要注意的是,使用該方法創建時,建議在OnSubscribe#call方法中檢查訂閱狀態,以便及時停止發射數據或者運算。
Observable.create(new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("item1"); subscriber.onNext("item2"); subscriber.onCompleted(); } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
from: 將一個Iterable, 一個Future, 或者一個數組,內部通過代理的方式轉換成一個Observable。Future轉換爲
OnSubscribe
是通過OnSubscribeToObservableFuture
進行的,Iterable轉換通過OnSubscribeFromIterable
進行。數組通過OnSubscribeFromArray
轉換。//Iterable List<String> list=new ArrayList<>(); ... Observable.from(list) .subscribe(new Action1<String>() { @Override public void call(String s) { } }); //Future Future<String> futrue= Executors.newSingleThreadExecutor().submit(new Callable<String>() { @Override public String call() throws Exception { Thread.sleep(1000); return "maplejaw"; } }); Observable.from(futrue) .subscribe(new Action1<String>() { @Override public void call(String s) { } }); ;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
just: 將一個或多個對象轉換成發射這個或這些對象的一個Observable。如果是單個對象,內部創建的是
ScalarSynchronousObservable
對象。如果是多個對象,則是調用了from方法創建。- empty: 創建一個什麼都不做直接通知完成的Observable
- error: 創建一個什麼都不做直接通知錯誤的Observable
never: 創建一個什麼都不做的Observable
Observable observable1=Observable.empty();//直接調用onCompleted。 Observable observable2=Observable.error(new RuntimeException());//直接調用onError。這裏可以自定義異常 Observable observable3=Observable.never();//啥都不做
- 1
- 2
- 3
timer: 創建一個在給定的延時之後發射數據項爲0的
Observable<Long>
,內部通過OnSubscribeTimerOnce
工作Observable.timer(1000,TimeUnit.MILLISECONDS) .subscribe(new Action1<Long>() { @Override public void call(Long aLong) { Log.d("JG",aLong.toString()); // 0 } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
interval: 創建一個按照給定的時間間隔發射從0開始的整數序列的
Observable<Long>
,內部通過OnSubscribeTimerPeriodically
工作。Observable.interval(1, TimeUnit.SECONDS) .subscribe(new Action1<Long>() { @Override public void call(Long aLong) { //每隔1秒發送數據項,從0開始計數 //0,1,2,3.... } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
range: 創建一個發射指定範圍的整數序列的
Observable<Integer>
Observable.range(2,5).subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.d("JG",integer.toString());// 2,3,4,5,6 從2開始發射5個數據 } });
- 1
- 2
- 3
- 4
- 5
- 6
defer: 只有當訂閱者訂閱才創建Observable,爲每個訂閱創建一個新的Observable。內部通過
OnSubscribeDefer
在訂閱時調用Func0創建Observable。Observable.defer(new Func0<Observable<String>>() { @Override public Observable<String> call() { return Observable.just("hello"); } }).subscribe(new Action1<String>() { @Override public void call(String s) { Log.d("JG",s); } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
合併操作
以下操作符用於組合多個Observable。
注意,爲了使結構更加清晰以及縮小代碼量,之後的例子部分地方將會使用Lambda表達式書寫,如果你對Lambda表達式不太熟悉的話,可以閱讀JAVA8 Lambda表達式完全解析這篇文章。
concat: 按順序連接多個Observables。需要注意的是
Observable.concat(a,b)
等價於a.concatWith(b)
。Observable<Integer> observable1=Observable.just(1,2,3,4); Observable<Integer> observable2=Observable.just(4,5,6); Observable.concat(observable1,observable2) .subscribe(item->Log.d("JG",item.toString()));//1,2,3,4,4,5,6
- 1
- 2
- 3
- 4
- 5
startWith: 在數據序列的開頭增加一項數據。
startWith
的內部也是調用了concat
Observable.just(1,2,3,4,5) .startWith(6,7,8) .subscribe(item->Log.d("JG",item.toString()));//6,7,8,1,2,3,4,5
- 1
- 2
- 3
merge: 將多個Observable合併爲一個。不同於concat,merge不是按照添加順序連接,而是按照時間線來連接。其中
mergeDelayError
將異常延遲到其它沒有錯誤的Observable發送完畢後才發射。而merge
則是一遇到異常將停止發射數據,發送onError通知。zip: 使用一個函數組合多個Observable發射的數據集合,然後再發射這個結果。如果多個Observable發射的數據量不一樣,則以最少的Observable爲標準進行壓合。內部通過
OperatorZip
進行壓合。Observable<Integer> observable1=Observable.just(1,2,3,4); Observable<Integer> observable2=Observable.just(4,5,6); Observable.zip(observable1, observable2, new Func2<Integer, Integer, String>() { @Override public String call(Integer item1, Integer item2) { return item1+"and"+item2; } }) .subscribe(item->Log.d("JG",item)); //1and4,2and5,3and6
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
combineLatest: 。當兩個Observables中的任何一個發射了一個數據時,通過一個指定的函數組合每個Observable發射的最新數據(一共兩個數據),然後發射這個函數的結果。類似於zip,但是,不同的是zip只有在每個Observable都發射了數據才工作,而combineLatest任何一個發射了數據都可以工作,每次與另一個Observable最近的數據壓合。具體請看下面流程圖。
zip工作流程combineLatest工作流程
過濾操作
filter: 過濾數據。內部通過
OnSubscribeFilter
過濾數據。Observable.just(3,4,5,6) .filter(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer integer) { return integer>4; } }) .subscribe(item->Log.d("JG",item.toString())); //5,6
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
ofType: 過濾指定類型的數據,與filter類似,
Observable.just(1,2,"3") .ofType(Integer.class) .subscribe(item -> Log.d("JG",item.toString()));
- 1
- 2
- 3
take: 只發射開始的N項數據或者一定時間內的數據。內部通過
OperatorTake
和OperatorTakeTimed
過濾數據。Observable.just(3,4,5,6) .take(3)//發射前三個數據項 .take(100, TimeUnit.MILLISECONDS)//發射100ms內的數據
- 1
- 2
- 3
takeLast: 只發射最後的N項數據或者一定時間內的數據。內部通過
OperatorTakeLast
和OperatorTakeLastTimed
過濾數據。takeLastBuffer和takeLast類似,不同點在於takeLastBuffer會收集成List後發射。Observable.just(3,4,5,6) .takeLast(3) .subscribe(integer -> Log.d("JG",integer.toString()));//4,5,6
- 1
- 2
- 3
takeFirst:提取滿足條件的第一項。內部實現源碼如下:
public final Observable<T> takeFirst(Func1<? super T, Boolean> predicate) { return filter(predicate).take(1); //先過濾,後提取 }
- 1
- 2
- 3
first/firstOrDefault:只發射第一項(或者滿足某個條件的第一項)數據,可以指定默認值。
Observable.just(3,4,5,6) .first() .subscribe(integer -> Log.d("JG",integer.toString()));//3 Observable.just(3,4,5,6) .first(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer integer) { return integer>3; } }) .subscribe(integer -> Log.d("JG",integer.toString()));//4
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
last/lastOrDefault:只發射最後一項(或者滿足某個條件的最後一項)數據,可以指定默認值。
skip:跳過開始的N項數據或者一定時間內的數據。內部通過
OperatorSkip
和OperatorSkipTimed
實現過濾。Observable.just(3,4,5,6) .skip(1) .subscribe(integer -> Log.d("JG",integer.toString()));//4,5,6
- 1
- 2
- 3
skipLast:跳過最後的N項數據或者一定時間內的數據。內部通過
OperatorSkipLast
和OperatorSkipLastTimed
實現過濾。- elementAt/elementAtOrDefault:發射某一項數據,如果超過了範圍可以的指定默認值。內部通過
OperatorElementAt
過濾。
Observable.just(3,4,5,6)
.elementAt(2)
.subscribe(item->Log.d("JG",item.toString())); //5
- 1
- 2
- 3
ignoreElements:丟棄所有數據,只發射錯誤或正常終止的通知。內部通過
OperatorIgnoreElements
實現。distinct:過濾重複數據,內部通過
OperatorDistinct
實現。Observable.just(3,4,5,6,3,3,4,9) .distinct() .subscribe(item->Log.d("JG",item.toString())); //3,4,5,6,9
- 1
- 2
- 3
distinctUntilChanged:過濾掉連續重複的數據。內部通過
OperatorDistinctUntilChanged
實現Observable.just(3,4,5,6,3,3,4,9) .distinctUntilChanged() .subscribe(item->Log.d("JG",item.toString())); //3,4,5,6,3,4,9
- 1
- 2
- 3
throttleFirst:定期發射Observable發射的第一項數據。內部通過
OperatorThrottleFirst
實現。Observable.create(subscriber -> { subscriber.onNext(1); try { Thread.sleep(500); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(2); try { Thread.sleep(500); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(3); try { Thread.sleep(1000); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(4); subscriber.onNext(5); subscriber.onCompleted(); }).throttleFirst(999, TimeUnit.MILLISECONDS) .subscribe(item-> Log.d("JG",item.toString())); //結果爲1,3,4
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
throttleWithTimeout/debounce:發射數據時,如果兩次數據的發射間隔小於指定時間,就會丟棄前一次的數據,直到指定時間內都沒有新數據發射時
才進行發射Observable.create(subscriber -> { subscriber.onNext(1); try { Thread.sleep(500); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(2); try { Thread.sleep(500); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(3); try { Thread.sleep(1000); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(4); subscriber.onNext(5); subscriber.onCompleted(); }).debounce(999, TimeUnit.MILLISECONDS)//或者爲throttleWithTimeout(1000, TimeUnit.MILLISECONDS) .subscribe(item-> Log.d("JG",item.toString())); //結果爲3,5
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
sample/throttleLast:定期發射Observable最近的數據。內部通過
OperatorSampleWithTime
實現。Observable.create(subscriber -> { subscriber.onNext(1); try { Thread.sleep(500); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(2); try { Thread.sleep(500); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(3); try { Thread.sleep(1000); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(4); subscriber.onNext(5); subscriber.onCompleted(); }).sample(999, TimeUnit.MILLISECONDS)//或者爲throttleLast(1000, TimeUnit.MILLISECONDS) .subscribe(item-> Log.d("JG",item.toString())); //結果爲2,3,5
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
timeout: 如果原始Observable過了指定的一段時長沒有發射任何數據,就發射一個異常或者使用備用的Observable。
Observable.create(( subscriber) -> { subscriber.onNext(1); try { Thread.sleep(1000); } catch (InterruptedException e) { throw Exceptions.propagate(e); } subscriber.onNext(2); subscriber.onCompleted(); }).timeout(999, TimeUnit.MILLISECONDS,Observable.just(99,100))//如果不指定備用Observable將會拋出異常 .subscribe(item-> Log.d("JG",item.toString()),error->Log.d("JG","onError")); //結果爲1,99,100 如果不指定備用Observable結果爲1,onError }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
條件/布爾操作
all: 判斷所有的數據項是否滿足某個條件,內部通過
OperatorAll
實現。Observable.just(2,3,4,5) .all(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer integer) { return integer>3; } }) .subscribe(new Action1<Boolean>() { @Override public void call(Boolean aBoolean) { Log.d("JG",aBoolean.toString()); //false } }) ;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
exists: 判斷是否存在數據項滿足某個條件。內部通過
OperatorAny
實現。Observable.just(2,3,4,5) .exists(integer -> integer>3) .subscribe(aBoolean -> Log.d("JG",aBoolean.toString())); //true
- 1
- 2
- 3
- 4
contains: 判斷在發射的所有數據項中是否包含指定的數據,內部調用的其實是
exists
Observable.just(2,3,4,5) .contains(3) .subscribe(aBoolean -> Log.d("JG",aBoolean.toString())); //true
- 1
- 2
- 3
sequenceEqual: 用於判斷兩個Observable發射的數據是否相同(數據,發射順序,終止狀態)。
Observable.sequenceEqual(Observable.just(2,3,4,5),Observable.just(2,3,4,5)) .subscribe(aBoolean -> Log.d("JG",aBoolean.toString()));//true
- 1
- 2
isEmpty: 用於判斷Observable發射完畢時,有沒有發射數據。有數據false,如果只收到了onComplete通知則爲true。
Observable.just(3,4,5,6) .isEmpty() .subscribe(item -> Log.d("JG",item.toString()));//false
- 1
- 2
- 3
amb: 給定多個Observable,只讓第一個發射數據的Observable發射全部數據,其他Observable將會被忽略。
Observable<Integer> observable1=Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { try { Thread.sleep(1000); } catch (InterruptedException e) { subscriber.onError(e); } subscriber.onNext(1); subscriber.onNext(2); subscriber.onCompleted(); } }).subscribeOn(Schedulers.computation()); Observable<Integer> observable2=Observable.create(subscriber -> { subscriber.onNext(3); subscriber.onNext(4); subscriber.onCompleted(); }); Observable.amb(observable1,observable2) .subscribe(integer -> Log.d("JG",integer.toString())); //3,4
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
switchIfEmpty: 如果原始Observable正常終止後仍然沒有發射任何數據,就使用備用的Observable。
Observable.empty() .switchIfEmpty(Observable.just(2,3,4)) .subscribe(o -> Log.d("JG",o.toString())); //2,3,4
- 1
- 2
- 3
- defaultIfEmpty: 如果原始Observable正常終止後仍然沒有發射任何數據,就發射一個默認值,內部調用的switchIfEmpty。
takeUntil: 當發射的數據滿足某個條件後(包含該數據),或者第二個Observable發送完畢,終止第一個Observable發送數據。
Observable.just(2,3,4,5) .takeUntil(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer integer) { return integer==4; } }).subscribe(integer -> Log.d("JG",integer.toString())); //2,3,4
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
takeWhile: 當發射的數據滿足某個條件時(不包含該數據),Observable終止發送數據。
Observable.just(2,3,4,5) .takeWhile(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer integer) { return integer==4; } }) .subscribe(integer -> Log.d("JG",integer.toString())); //2,3
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- skipUntil: 丟棄Observable發射的數據,直到第二個Observable發送數據。(丟棄條件數據)
- skipWhile: 丟棄Observable發射的數據,直到一個指定的條件不成立(不丟棄條件數據)
聚合操作
reduce: 對序列使用reduce()函數併發射最終的結果,內部使用
OnSubscribeReduce
實現。Observable.just(2,3,4,5) .reduce(new Func2<Integer, Integer, Integer>() { @Override public Integer call(Integer sum, Integer item) { return sum+item; } }) .subscribe(integer -> Log.d("JG",integer.toString()));//14
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
collect: 使用
collect
收集數據到一個可變的數據結構。Observable.just(3,4,5,6) .collect(new Func0<List<Integer>>() { //創建數據結構 @Override public List<Integer> call() { return new ArrayList<Integer>(); } }, new Action2<List<Integer>, Integer>() { //收集器 @Override public void call(List<Integer> integers, Integer integer) { integers.add(integer); } }) .subscribe(new Action1<List<Integer>>() { @Override public void call(List<Integer> integers) { } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
count/countLong: 計算髮射的數量,內部調用的是
reduce
.
轉換操作
toList: 收集原始Observable發射的所有數據到一個列表,然後返回這個列表.
Observable.just(2,3,4,5) .toList() .subscribe(new Action1<List<Integer>>() { @Override public void call(List<Integer> integers) { } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
toSortedList: 收集原始Observable發射的所有數據到一個有序列表,然後返回這個列表。
Observable.just(6,2,3,4,5) .toSortedList(new Func2<Integer, Integer, Integer>() {//自定義排序 @Override public Integer call(Integer integer, Integer integer2) { return integer-integer2; //>0 升序 ,<0 降序 } }) .subscribe(new Action1<List<Integer>>() { @Override public void call(List<Integer> integers) { Log.d("JG",integers.toString()); // [2, 3, 4, 5, 6] } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
toMap: 將序列數據轉換爲一個Map。我們可以根據數據項生成key和生成value。
Observable.just(6,2,3,4,5) .toMap(new Func1<Integer, String>() { @Override public String call(Integer integer) { return "key:" + integer; //根據數據項生成map的key } }, new Func1<Integer, String>() { @Override public String call(Integer integer) { return "value:"+integer; //根據數據項生成map的kvalue } }).subscribe(new Action1<Map<String, String>>() { @Override public void call(Map<String, String> stringStringMap) { Log.d("JG",stringStringMap.toString()); // {key:6=value:6, key:5=value:5, key:4=value:4, key:2=value:2, key:3=value:3} } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- toMultiMap: 類似於toMap,不同的地方在於map的value是一個集合。
變換操作
map: 對Observable發射的每一項數據都應用一個函數來變換。
Observable.just(6,2,3,4,5) .map(integer -> "item:"+integer) .subscribe(s -> Log.d("JG",s));//item:6,item:2....
- 1
- 2
- 3
- 4
- cast: 在發射之前強制將Observable發射的所有數據轉換爲指定類型
flatMap: 將Observable發射的數據變換爲Observables集合,然後將這些Observable發射的數據平坦化的放進一個單獨的Observable,內部採用merge合併。
Observable.just(2,3,5) .flatMap(new Func1<Integer, Observable<String>>() { @Override public Observable<String> call(Integer integer) { return Observable.create(subscriber -> { subscriber.onNext(integer*10+""); subscriber.onNext(integer*100+""); subscriber.onCompleted(); }); } }) .subscribe(o -> Log.d("JG",o)) //20,200,30,300,50,500
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
flatMapIterable: 和flatMap的作用一樣,只不過生成的是Iterable而不是Observable。
Observable.just(2,3,5) .flatMapIterable(new Func1<Integer, Iterable<String>>() { @Override public Iterable<String> call(Integer integer) { return Arrays.asList(integer*10+"",integer*100+""); } }).subscribe(new Action1<String>() { @Override public void call(String s) { } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- concatMap: 類似於flatMap,由於內部使用concat合併,所以是按照順序連接發射。
switchMap: 和flatMap很像,將Observable發射的數據變換爲Observables集合,當原始Observable發射一個新的數據(Observable)時,它將取消訂閱前一個Observable。
Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { for(int i=1;i<4;i++){ subscriber.onNext(i); Utils.sleep(500,subscriber);//線程休眠500ms } subscriber.onCompleted(); } }).subscribeOn(Schedulers.newThread()) .switchMap(new Func1<Integer, Observable<Integer>>() { @Override public Observable<Integer> call(Integer integer) { //每當接收到新的數據,之前的Observable將會被取消訂閱 return Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(integer*10); Utils.sleep(500,subscriber); subscriber.onNext(integer*100); subscriber.onCompleted(); } }).subscribeOn(Schedulers.newThread()); } }) .subscribe(s -> Log.d("JG",s.toString()));//10,20,30,300
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
scan: 與reduce很像,對Observable發射的每一項數據應用一個函數,然後按順序依次發射每一個值。
Observable.just(2,3,5) .scan(new Func2<Integer, Integer, Integer>() { @Override public Integer call(Integer sum, Integer item) { return sum+item; } }) .subscribe(integer -> Log.d("JG",integer.toString())) //2,5,10
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
groupBy: 將Observable分拆爲Observable集合,將原始Observable發射的數據按Key分組,每一個Observable發射一組不同的數據。
Observable.just(2,3,5,6) .groupBy(new Func1<Integer, String>() { @Override public String call(Integer integer) {//分組 return integer%2==0?"偶數":"奇數"; } }) .subscribe(new Action1<GroupedObservable<String, Integer>>() { @Override public void call(GroupedObservable<String, Integer> o) { o.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.d("JG",o.getKey()+":"+integer.toString()); //偶數:2,奇數:3,... } }); } })
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
buffer: 它定期從Observable收集數據到一個集合,然後把這些數據集合打包發射,而不是一次發射一個
Observable.just(2,3,5,6) .buffer(3) .subscribe(new Action1<List<Integer>>() { @Override public void call(List<Integer> integers) { } })
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
window: 定期將來自Observable的數據分拆成一些Observable窗口,然後發射這些窗口,而不是每次發射一項。
Observable.just(2,3,5,6) .window(3) .subscribe(new Action1<Observable<Integer>>() { @Override public void call(Observable<Integer> integerObservable) { integerObservable.subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { } }); } })
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
錯誤處理/重試機制
onErrorResumeNext: 當原始Observable在遇到錯誤時,使用備用Observable。。
Observable.just(1,"2",3) .cast(Integer.class) .onErrorResumeNext(Observable.just(1,2,3)) .subscribe(integer -> Log.d("JG",integer.toString())) //1,2,3 ;
- 1
- 2
- 3
- 4
- 5
- 6
- onExceptionResumeNext: 當原始Observable在遇到異常時,使用備用的Observable。與
onErrorResumeNext
類似,區別在於onErrorResumeNext
可以處理所有的錯誤,onExceptionResumeNext只能處理異常。 onErrorReturn: 當原始Observable在遇到錯誤時發射一個特定的數據。
Observable.just(1,"2",3) .cast(Integer.class) .onErrorReturn(new Func1<Throwable, Integer>() { @Override public Integer call(Throwable throwable) { return 4; } }).subscribe(new Action1<Integer>() { @Override public void call(Integer integer) { Log.d("JG",integer.toString());1,4 } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
retry: 當原始Observable在遇到錯誤時進行重試。
Observable.just(1,"2",3) .cast(Integer.class) .retry(3) .subscribe(integer -> Log.d("JG",integer.toString()),throwable -> Log.d("JG","onError")) ;//1,1,1,1,onError
- 1
- 2
- 3
- 4
- 5
- 6
retryWhen: 當原始Observable在遇到錯誤,將錯誤傳遞給另一個Observable來決定是否要重新訂閱這個Observable,內部調用的是
retry
。Observable.just(1,"2",3) .cast(Integer.class) .retryWhen(new Func1<Observable<? extends Throwable>, Observable<Long>>() { @Override public Observable<Long> call(Observable<? extends Throwable> observable) { return Observable.timer(1, TimeUnit.SECONDS); } }) .subscribe(integer -> Log.d("JG",integer.toString()),throwable -> Log.d("JG","onError")); //1,1
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
連接操作
ConnectableObservable
與普通的Observable差不多,但是可連接的Observable在被訂閱時並不開始發射數據,只有在它的connect()被調用時纔開始。用這種方法,你可以等所有的潛在訂閱者都訂閱了這個Observable之後纔開始發射數據。 ConnectableObservable.connect()
指示一個可連接的Observable開始發射數據. Observable.publish()
將一個Observable轉換爲一個可連接的Observable Observable.replay()
確保所有的訂閱者看到相同的數據序列的ConnectableObservable
,即使它們在Observable開始發射數據之後才訂閱。 ConnectableObservable.refCount()
讓一個可連接的Observable表現得像一個普通的Observable。
ConnectableObservable<Integer> co= Observable.just(1,2,3)
.publish();
co .subscribe(integer -> Log.d("JG",integer.toString()) );
co.connect();//此時開始發射數據
- 1
- 2
- 3
- 4
- 5
- 6
- 7
阻塞操作
BlockingObservable
是一個阻塞的Observable。普通的Observable 轉換爲 BlockingObservable,可以使用 Observable.toBlocking( )
方法或者BlockingObservable.from( )
方法。內部通過CountDownLatch
實現了阻塞操作。
以下的操作符可以用於BlockingObservable,如果是普通的Observable,務必使用Observable.toBlocking()轉爲阻塞Observable後使用,否則達不到預期的效果。
forEach: 對BlockingObservable發射的每一項數據調用一個方法,會阻塞直到Observable完成。
Observable.just(2,3).observeOn(Schedulers.newThread()).toBlocking() .forEach(integer -> { Log.d("JG",integer.toString()+" "+Thread.currentThread().getName()); Utils.sleep(500); }); Log.d("JG",Thread.currentThread().getName()); // 2 RxNewThreadScheduler-1 // 3 RxNewThreadScheduler-1 // main
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- first/firstOrDefault/last/lastOrDefault:這幾個操作符之前有介紹過。也可以用於阻塞操作。
- single/singleOrDefault:如果Observable終止時只發射了一個值,返回那個值,否則拋出異常或者發射默認值。
- mostRecent:返回一個總是返回Observable最近發射的數據的Iterable。
- next: 返回一個Iterable,會阻塞直到Observable發射了第二個值,然後返回那個值。
- latest: 返回一個iterable,會阻塞直到或者除非Observable發射了一個iterable沒有返回的值,然後返回這個值
- toFuture: 將Observable轉換爲一個Future
- toIterable:將一個發射數據序列的Observable轉換爲一個Iterable。
- getIterator:將一個發射數據序列的Observable轉換爲一個Iterator
工具集
materialize: 將Observable轉換成一個通知列表。
Observable.just(1,2,3) .materialize() .subscribe(new Action1<Notification<Integer>>() { @Override public void call(Notification<Integer> notification) { Log.d("JG",notification.getKind()+" "+notification.getValue()); //OnNext 1 //OnNext 2 //OnNext 3 //OnCompleted null } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- dematerialize: 與上面的作用相反,將通知逆轉回一個Observable。
timestamp: 給Observable發射的每個數據項添加一個時間戳。
Observable.just(1,2,3) .timestamp() .subscribe(new Action1<Timestamped<Integer>>() { @Override public void call(Timestamped<Integer> timestamped) { Log.d("JG",timestamped.getTimestampMillis()+" "+timestamped.getValue()); //1472627510548 1 //1472627510549 2 //1472627510549 3 } });
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
timeInterval:給Observable發射的兩個數據項間添加一個時間差,實現在
OperatorTimeInterval
中- serialize: 強制Observable按次序發射數據並且要求功能是完好的
- cache: 緩存Observable發射的數據序列併發射相同的數據序列給後續的訂閱者
- observeOn: 指定觀察者觀察Observable的調度器
- subscribeOn: 指定Observable執行任務的調度器
doOnEach: 註冊一個動作,對Observable發射的每個數據項使用
Observable.just(2,3) .doOnEach(new Action1<Notification<? super Integer>>() { @Override public void call(Notification<? super Integer> notification) { Log.d("JG","--doOnEach--"+notification.toString()); } }) .subscribe(integer -> Log.d("JG",integer.toString())); //結果爲: // --doOnEach--[rx.Notification@133c40b0 OnNext 2] // 2 // --doOnEach--[rx.Notification@133c40b0 OnNext 3] // 3 // --doOnEach--[rx.Notification@df4db0e OnCompleted]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
doOnCompleted: 註冊一個動作,對正常完成的Observable使用
- doOnError: 註冊一個動作,對發生錯誤的Observable使用
doOnTerminate:註冊一個動作,對完成的Observable使用,無論是否發生錯誤
Observable.just(2,3) .doOnTerminate(new Action0() { @Override public void call() { Log.d("JG","--doOnTerminate--"); } }) .subscribe(integer -> Log.d("JG",integer.toString())); // 2 , 3 , --doOnTerminate--
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- doOnSubscribe: 註冊一個動作,在觀察者訂閱時使用。內部由
OperatorDoOnSubscribe
實現, - doOnUnsubscribe: 註冊一個動作,在觀察者取消訂閱時使用。內部由
OperatorDoOnUnsubscribe
實現,在call
中加入一個解綁動作。 finallyDo/doAfterTerminate: 註冊一個動作,在Observable完成時使用
Observable.just(2,3) .doAfterTerminate(new Action0() { @Override public void call() { Log.d("JG","--doAfterTerminate--"); } }) .subscribe(integer -> Log.d("JG",integer.toString())); //2,3, --doAfterTerminate--
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
delay: 延時發射Observable的結果。即讓原始Observable在發射每項數據之前都暫停一段指定的時間段。效果是Observable發射的數據項在時間上向前整體平移了一個增量(除了onError,它會即時通知)。
delaySubscription: 延時處理訂閱請求。實現在
OnSubscribeDelaySubscription
中using: 創建一個只在Observable生命週期存在的資源,當Observable終止時這個資源會被自動釋放。
Observable.using(new Func0<File>() {//資源工廠 @Override public File call() { File file = new File(getCacheDir(), "a.txt"); if(!file.exists()){ try { Log.d("JG","--create--"); file.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } return file; } }, new Func1<File, Observable<String>>() { //Observable @Override public Observable<String> call(File file) { return Observable.just(file.exists() ? "exist" : "no exist"); } }, new Action1<File>() {//釋放資源動作 @Override public void call(File file) { if(file!=null&&file.exists()){ Log.d("JG","--delete--"); file.delete(); } } }) .subscribe(s -> Log.d("JG",s)) ; //--create-- //exist //--delete--
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- single/singleOrDefault: 強制返回單個數據,否則拋出異常或默認數據。
最後
關於RxJava標準庫的操作符已經介紹完畢,純粹當個備忘錄。如有錯誤之處,歡迎指出