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)”的方式，這就能保證產生結果的順序性，也就是說提交給訂閱者的結果是按照順序提交的，不會存在交叉的情況。
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產生的結果，通過映射規則轉換成另一個結果集，并提交給訂閱者進行處理。
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運行時異常。
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產生的結果，依次對每一個結果項按照指定規則進行運算，計算后的結果作為下一個迭代項參數，每一次迭代項都會把計算結果輸出給訂閱者。
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重新進行訂閱處理。
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
