Android RxJava使用介紹（三） RxJava的操作符
上一篇文章已經詳細講解了RxJava的建立型操作符，本片文章將繼續講解RxJava操作符，包括：
- Transforming Observables(Observable的轉換操作符)
- Filtering Observables(Observable的過濾操作符)
Transforming Observables(Observable的轉換操作符)
buffer操作符
buffer操作符週期性地收集源Observable產生的結果到列表中，並把這個列表提交給訂閱者，訂閱者處理後，清空buffer列表，同時接收下一次收集的結果並提交給訂閱者，周而復始。
需要注意的是，一旦源Observable在產生結果的過程中出現異常，即使buffer已經存在收集到的結果，訂閱者也會馬上收到這個異常，並結束整個過程。
buffer的名字很怪，但是原理很簡單，流程圖如下： 
呼叫例子如下：
//定義郵件內容
final String[] mails = new String[]{"Here is an email!", "Another email!", "Yet another email!"};
//每隔1秒就隨機發布一封郵件
Observable<String> endlessMail = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
try {
if (subscriber.isUnsubscribed()) return;
Random random = new Random();
while (true) {
String mail = mails[random.nextInt(mails.length)];
subscriber.onNext(mail);
Thread.sleep(1000);
}
} catch (Exception ex) {
subscriber.onError(ex);
}
}
}).subscribeOn(Schedulers.io());
//把上面產生的郵件內容快取到列表中，並每隔3秒通知訂閱者
endlessMail.buffer(3, TimeUnit.SECONDS).subscribe(new Action1<List<String>>() {
@Override
public void call(List<String> list) {
System.out.println(String.format("You've got %d new messages! Here they are!", list.size()));
for (int i = 0; i < list.size(); i++)
System.out.println("**" + list.get(i).toString());
}
});執行結果如下：
You’ve got 3 new messages! Here they are!(after 3s)
**Here is an email!
**Another email!
**Another email!
You’ve got 3 new messages! Here they are!(after 6s)
**Here is an email!
**Another email!
**Here is an email!
……
flatMap操作符
flatMap操作符是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。
flatMap操作符通過傳入一個函式作為引數轉換源Observable，在這個函式中，你可以自定義轉換規則，最後在這個函式中返回一個新的Observable，然後flatMap操作符通過合併這些Observable結果成一個Observable，並依次提交結果給訂閱者。
值得注意的是，flatMap操作符在合併Observable結果時，有可能存在交叉的情況，如下流程圖所示： 
呼叫例子如下：
private Observable<File> listFiles(File f){
if(f.isDirectory()){
return Observable.from(f.listFiles()).flatMap(new Func1<File, Observable<File>>() {
@Override
public Observable<File> call(File file) {
return listFiles(f);
}
});
} else {
return Observable.just(f);
}
}
@Override
public void onClick(View v) {
Observable.just(getApplicationContext().getExternalCacheDir())
.flatMap(new Func1<File, Observable<File>>() {
@Override
public Observable<File> call(File file) {
//引數file是just操作符產生的結果，這裡判斷file是不是目錄檔案，如果是目錄檔案，則遞迴查詢其子檔案flatMap操作符神奇的地方在於，返回的結果還是一個Observable，而這個Observable其實是包含多個檔案的Observable的，輸出應該是ExternalCacheDir下的所有檔案
return listFiles(file);
}
})
.subscribe(new Action1<File>() {
@Override
public void call(File file) {
System.out.println(file.getAbsolutePath());
}
});
}concatMap操作符
cancatMap操作符與flatMap操作符類似，都是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。
與flatMap操作符不同的是，concatMap操作符在處理產生的Observable時，採用的是“連線(concat)”的方式，而不是“合併(merge)”的方式，這就能保證產生結果的順序性，也就是說提交給訂閱者的結果是按照順序提交的，不會存在交叉的情況。
concatMap的流程如下： 
concatMap的呼叫例子與flatMap類似，這裡不做重複
switchMap操作符
switchMap操作符與flatMap操作符類似，都是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。
與flatMap操作符不同的是，switchMap操作符會儲存最新的Observable產生的結果而捨棄舊的結果，舉個例子來說，比如源Observable產生A、B、C三個結果，通過switchMap的自定義對映規則，對映後應該會產生A1、A2、B1、B2、C1、C2，但是在產生B2的同時，C1已經產生了，這樣最後的結果就變成A1、A2、B1、C1、C2，B2被捨棄掉了！流程圖如下：
以下是flatMap、concatMap和switchMap的執行例項對比：
//flatMap操作符的執行結果
Observable.just(10, 20, 30).flatMap(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer integer) {
//10的延遲執行時間為200毫秒、20和30的延遲執行時間為180毫秒
int delay = 200;
if (integer > 10)
delay = 180;
return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("flatMap Next:" + integer);
}
});
//concatMap操作符的執行結果
Observable.just(10, 20, 30).concatMap(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer integer) {
//10的延遲執行時間為200毫秒、20和30的延遲執行時間為180毫秒
int delay = 200;
if (integer > 10)
delay = 180;
return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("concatMap Next:" + integer);
}
});
//switchMap操作符的執行結果
Observable.just(10, 20, 30).switchMap(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer integer) {
//10的延遲執行時間為200毫秒、20和30的延遲執行時間為180毫秒
int delay = 200;
if (integer > 10)
delay = 180;
return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
}
}).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("switchMap Next:" + integer);
}
});執行結果如下：
flatMap Next:20
flatMap Next:10
flatMap Next:30
flatMap Next:15
flatMap Next:10
flatMap Next:5
switchMap Next:30
switchMap Next:15
concatMap Next:10
concatMap Next:5
concatMap Next:20
concatMap Next:10
concatMap Next:30
concatMap Next:15
groupBy操作符
groupBy操作符是對源Observable產生的結果進行分組，形成一個型別為GroupedObservable的結果集，GroupedObservable中存在一個方法為getKey()，可以通過該方法獲取結果集的Key值（類似於HashMap的key)。
值得注意的是，由於結果集中的GroupedObservable是把分組結果快取起來，如果對每一個GroupedObservable不進行處理（既不訂閱執行也不對其進行別的操作符運算），就有可能出現記憶體洩露。因此，如果你對某個GroupedObservable不進行處理，最好是對其使用操作符take(0)處理。
groupBy操作符的流程圖如下： 
呼叫例子如下：
Observable.interval(1, TimeUnit.SECONDS).take(10).groupBy(new Func1<Long, Long>() {
@Override
public Long call(Long value) {
//按照key為0,1,2分為3組
return value % 3;
}
}).subscribe(new Action1<GroupedObservable<Long, Long>>() {
@Override
public void call(GroupedObservable<Long, Long> result) {
result.subscribe(new Action1<Long>() {
@Override
public void call(Long value) {
System.out.println("key:" + result.getKey() +", value:" + value);
}
});
}
});執行結果如下：
key:0, value:0
key:1, value:1
key:2, value:2
key:0, value:3
key:1, value:4
key:2, value:5
key:0, value:6
key:1, value:7
key:2, value:8
key:0, value:9
map操作符
map操作符是把源Observable產生的結果，通過對映規則轉換成另一個結果集，並提交給訂閱者進行處理。
map操作符的流程圖如下： 
呼叫例子如下：
Observable.just(1,2,3,4,5,6).map(new Func1<Integer, Integer>() {
@Override
public Integer call(Integer integer) {
//對源Observable產生的結果，都統一乘以3處理
return integer*3;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("next:" + integer);
}
});執行結果如下：
next:3
next:6
next:9
next:12
next:15
next:18
cast操作符
cast操作符類似於map操作符，不同的地方在於map操作符可以通過自定義規則，把一個值A1變成另一個值A2，A1和A2的型別可以一樣也可以不一樣；而cast操作符主要是做型別轉換的，傳入引數為型別class，如果源Observable產生的結果不能轉成指定的class，則會丟擲ClassCastException執行時異常。
cast操作符的流程圖如下： 
呼叫例子如下：
Observable.just(1,2,3,4,5,6).cast(Integer.class).subscribe(new Action1<Integer>() {
@Override
public void call(Integer value) {
System.out.println("next:"+value);
}
});執行結果如下：
next:1
next:2
next:3
next:4
next:5
next:6
scan操作符
scan操作符通過遍歷源Observable產生的結果，依次對每一個結果項按照指定規則進行運算，計算後的結果作為下一個迭代項引數，每一次迭代項都會把計算結果輸出給訂閱者。
scan操作符的流程圖如下： 
呼叫例子如下：
Observable.just(1, 2, 3, 4, 5)
.scan(new Func2<Integer, Integer, Integer>() {
@Override
public Integer call(Integer sum, Integer item) {
//引數sum就是上一次的計算結果
return sum + item;
}
}).subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 1
Next: 3
Next: 6
Next: 10
Next: 15
Sequence complete.
window操作符
window操作符非常類似於buffer操作符，區別在於buffer操作符產生的結果是一個List快取，而window操作符產生的結果是一個Observable，訂閱者可以對這個結果Observable重新進行訂閱處理。
window操作符有很多個過載方法，這裡只舉一個簡單的例子，其流程圖如下： 
呼叫例子如下：
Observable.interval(1, TimeUnit.SECONDS).take(12)
.window(3, TimeUnit.SECONDS)
.subscribe(new Action1<Observable<Long>>() {
@Override
public void call(Observable<Long> observable) {
System.out.println("subdivide begin......");
observable.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
System.out.println("Next:" + aLong);
}
});
}
});執行結果如下：
subdivide begin……
Next:0
Next:1
subdivide begin……
Next:2
Next:3
Next:4
subdivide begin……
Next:5
Next:6
Next:7
subdivide begin……
Next:8
Next:9
Next:10
subdivide begin……
Next:11
Filtering Observables(Observable的過濾操作符)
debounce操作符
debounce操作符對源Observable每產生一個結果後，如果在規定的間隔時間內沒有別的結果產生，則把這個結果提交給訂閱者處理，否則忽略該結果。
值得注意的是，如果源Observable產生的最後一個結果後在規定的時間間隔內呼叫了onCompleted，那麼通過debounce操作符也會把這個結果提交給訂閱者。
debounce操作符的流程圖如下： 
呼叫例子如下：
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
if(subscriber.isUnsubscribed()) return;
try {
//產生結果的間隔時間分別為100、200、300...900毫秒
for (int i = 1; i < 10; i++) {
subscriber.onNext(i);
Thread.sleep(i * 100);
}
subscriber.onCompleted();
}catch(Exception e){
subscriber.onError(e);
}
}
}).subscribeOn(Schedulers.newThread())
.debounce(400, TimeUnit.MILLISECONDS) //超時時間為400毫秒
.subscribe(
new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("Next:" + integer);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
System.out.println("Error:" + throwable.getMessage());
}
}, new Action0() {
@Override
public void call() {
System.out.println("completed!");
}
});執行結果如下：
Next:4
Next:5
Next:6
Next:7
Next:8
Next:9
completed!
distinct操作符
distinct操作符對源Observable產生的結果進行過濾，把重複的結果過濾掉，只輸出不重複的結果給訂閱者，非常類似於SQL裡的distinct關鍵字。
distinct操作符的流程圖如下： 
呼叫例子如下：
Observable.just(1, 2, 1, 1, 2, 3)
.distinct()
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 1
Next: 2
Next: 3
Sequence complete.
elementAt操作符
elementAt操作符在源Observable產生的結果中，僅僅把指定索引的結果提交給訂閱者，索引是從0開始的。其流程圖如下： 
呼叫例子如下：
Observable.just(1,2,3,4,5,6).elementAt(2)
.subscribe(
new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("Next:" + integer);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
System.out.println("Error:" + throwable.getMessage());
}
}, new Action0() {
@Override
public void call() {
System.out.println("completed!");
}
});執行結果如下：
Next:3
completed!
filter操作符
filter操作符是對源Observable產生的結果按照指定條件進行過濾，只有滿足條件的結果才會提交給訂閱者，其流程圖如下： 
呼叫例子如下：
Observable.just(1, 2, 3, 4, 5)
.filter(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer item) {
return( item < 4 );
}
}).subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 1
Next: 2
Next: 3
Sequence complete.
ofType操作符
ofType操作符類似於filter操作符，區別在於ofType操作符是按照型別對結果進行過濾，其流程圖如下： 
呼叫例子如下：
Observable.just(1, "hello world", true, 200L, 0.23f)
.ofType(Float.class)
.subscribe(new Subscriber<Object>() {
@Override
public void onNext(Object item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 0.23
Sequence complete.
first操作符
first操作符是把源Observable產生的結果的第一個提交給訂閱者，first操作符可以使用elementAt(0)和take(1)替代。其流程圖如下：
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7,8)
.first()
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 1
Sequence complete.
single操作符
single操作符是對源Observable的結果進行判斷，如果產生的結果滿足指定條件的數量不為1，則丟擲異常，否則把滿足條件的結果提交給訂閱者，其流程圖如下：
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7,8)
.single(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
//取大於10的第一個數字
return integer>10;
}
})
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Error: Sequence contains no elements
last操作符
last操作符把源Observable產生的結果的最後一個提交給訂閱者，last操作符可以使用takeLast(1)替代。其流程圖如下： 
呼叫例子如下：
Observable.just(1, 2, 3)
.last()
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 3
Sequence complete.
ignoreElements操作符
ignoreElements操作符忽略所有源Observable產生的結果，只把Observable的onCompleted和onError事件通知給訂閱者。ignoreElements操作符適用於不太關心Observable產生的結果，只是在Observable結束時(onCompleted)或者出現錯誤時能夠收到通知。
ignoreElements操作符的流程圖如下： 
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7,8).ignoreElements()
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Sequence complete.
sample操作符
sample操作符定期掃描源Observable產生的結果，在指定的時間間隔範圍內對源Observable產生的結果進行取樣，其流程圖如下： 
呼叫例子如下：
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
if(subscriber.isUnsubscribed()) return;
try {
//前8個數字產生的時間間隔為1秒，後一個間隔為3秒
for (int i = 1; i < 9; i++) {
subscriber.onNext(i);
Thread.sleep(1000);
}
Thread.sleep(2000);
subscriber.onNext(9);
subscriber.onCompleted();
} catch(Exception e){
subscriber.onError(e);
}
}
}).subscribeOn(Schedulers.newThread())
.sample(2200, TimeUnit.MILLISECONDS) //取樣間隔時間為2200毫秒
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 3
Next: 5
Next: 7
Next: 8
Sequence complete.
skip操作符
skip操作符針對源Observable產生的結果，跳過前面n個不進行處理，而把後面的結果提交給訂閱者處理，其流程圖如下： 
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7).skip(3)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 4
Next: 5
Next: 6
Next: 7
Sequence complete.
skipLast操作符
skipLast操作符針對源Observable產生的結果，忽略Observable最後產生的n個結果，而把前面產生的結果提交給訂閱者處理，
值得注意的是，skipLast操作符提交滿足條件的結果給訂閱者是存在延遲效果的，看以下流程圖即可明白： 
可以看到skipLast操作符把最後的天藍色球、藍色球、紫色球忽略掉了，但是前面的紅色球等並不是源Observable一產生就直接提交給訂閱者，這裡有一個延遲的效果。
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7).skipLast(3)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.
take操作符
take操作符是把源Observable產生的結果，提取前面的n個提交給訂閱者，而忽略後面的結果，其流程圖如下： 
呼叫例子如下：
Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
.take(4)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.
takeFirst操作符
takeFirst操作符類似於take操作符，同時也類似於first操作符，都是獲取源Observable產生的結果列表中符合指定條件的前一個或多個，與first操作符不同的是，first操作符如果獲取不到資料，則會丟擲NoSuchElementException異常，而takeFirst則會返回一個空的Observable，該Observable只有onCompleted通知而沒有onNext通知。
takeFirst操作符的流程圖如下： 
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7).takeFirst(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
//獲取數值大於3的資料
return integer>3;
}
})
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 4
Sequence complete.
takeLast操作符
takeLast操作符是把源Observable產生的結果的後n項提交給訂閱者，提交時機是Observable釋出onCompleted通知之時。其流程圖如下：
呼叫例子如下：
Observable.just(1,2,3,4,5,6,7).takeLast(2)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}
@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});執行結果如下：
Next: 6
Next: 7
Sequence complete.
不知不覺介紹了那麼多操作符，篇幅有點長了，下回繼續介紹其他的操作符，敬請期待！
相關文章
- Android RxJava使用介紹（二） RxJava的操作符AndroidRxJava
- Android RxJava使用介紹（四） RxJava的操作符AndroidRxJava
- Android RxJava：基礎介紹與使用AndroidRxJava
- Android RxJava使用介紹（一） Hello WorldAndroidRxJava
- RxJava操作符系列三RxJava
- Rxjava2操作符(三)RxJava
- RxJava操作符之建立操作符(三)RxJava
- RxJava常用操作符RxJava
- RxJava操作符列表RxJava
- 大話RxJava：三、RxJava的中級使用方法RxJava
- Kotlin 使用Rxjava的compose()操作符KotlinRxJava
- RxJava 和 RxAndroid 二（操作符的使用）RxJavaAndroid
- 3章 RxJava操作符RxJava
- RxJava 操作符系列二RxJava
- RxJava操作符系列一RxJava
- RxJava操作符系列二RxJava
- RxJava 操作符系列五RxJava
- RxJava操作符系列四RxJava
- RxJava 知識梳理(2) RxJava2 操作符實戰RxJava
- part05_Rxjava操作符RxJava
- Rxjava2操作符(二)RxJava
- 詳解Android RxJava的使用AndroidRxJava
- Rxjava2的簡單使用與基本操作符RxJava
- 一篇不太一樣的RxJava介紹（二）：關於操作符背後的故事RxJava
- 一篇不太一樣的RxJava介紹RxJava
- RxJava操作符之組合操作符(六)RxJava
- RxJava操作符之轉換操作符(四)RxJava
- RxJava操作符之過濾操作符(五)RxJava
- 解剖 RxJava 之變換操作符RxJava
- RxJava2 操作符總結RxJava
- RxJava2.0——變換操作符RxJava
- 解剖 RxJava 之過濾操作符RxJava
- RxJava操作符之Transforming ObservablesRxJavaORM
- 深入淺出RxJava（2）：操作符RxJava
- 深入淺出RxJava(二：操作符)RxJava
- Android 淺析 RxJava (一) 使用AndroidRxJava
- Rxjava2操作符入門(一)RxJava
- RxJava操作符之Creating ObservablesRxJava