RxJava操作符學習筆記

操作符

操作符是為了解決對Observable對象的變換的問題，操作符用于在Observable和最終的Subscriber之間修改Observable發出的事件。
RxJava提供了很多很有用的操作符。

Subscribers更應該做的事情是“響應”，響應Observable發出的事件，而不是去修改。

所以修改就交給操作符吧.

Map

transform the items emitted by an Observable by applying a function to each item

用來把一個事件轉換為另一個事件。
map()操作符就是用于變換Observable對象的，map操作符返回一個Observable對象，這樣就可以實現鏈式調用，在一個Observable對象上多次使用map操作符，最終將最簡潔的數據傳遞給Subscriber對象。

原理

實效

特性:

1. 它不必返回Observable對象返回的類型，你可以使用map操作符返回一個發出新的數據類型的observable對象。
2. 可以對一個Observable多次使用map

用一個例子來練習:

//剛創建的Observable是String類型的 Observable.just("Hellp Map Operator")
.map(new Func1<String, Integer>() { @Override public Integer call(String s) { return 2015;//通過第一個map轉成Integer }
}).map(new Func1<Integer, String>() { @Override public String call(Integer integer) { return String.valueOf(integer);//再通過第二個map轉成String }
}).subscribe(new Action1<String>() { @Override public void call(String s) {
        System.out.println(s);
    }
});

Run起來輸出日志:

2015

From

convert various other objects and data types into Observables

from()接收一個集合作為輸入，然后每次輸出一個元素給subscriber.

from

看個例子,將集合的數據都輸出:

List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift");
Observable.from(s).subscribe(new Action1<String>() {
    @Override public void call(String s) {
        System.out.println(s);
    }
});

Log:

Java
Android
Ruby
Ios
Swift

另外from也接受數組類型:

Observable.from(new String[]{"Java","Android"}).subscribe(new Action1<String>() {
    @Override public void call(String s) {
        System.out.println(s);
    }
});

FlatMap

transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable

Observable.flatMap()接收一個Observable的輸出作為輸入，同時輸出另外一個Observable。

先加一個函數

static Observable<List<String>>query(){ List<String> s = Arrays.asList("Java", "Android", "Ruby", "Ios", "Swift"); return Observable.just(s);
}

我們打印所有query到的語言:

// 注意這里的參數是 query所返回的Observable的輸出,并且返會一個Observable<String> query().flatMap(new Func1<List<String>, Observable<String>>() {
    @Override public Observable<String> call(List<String> strings) { //結合from處理 return Observable.from(strings);
    }
}).subscribe(new Action1<String>() {
    @Override public void call(String s) {
        System.out.println("_flatMap:"+s);
    }
});

日志:

_from:Java
_from:Android
_flatMap:Java
_flatMap:Android
_flatMap:Ruby
_flatMap:Ios
_flatMap:Swift

注意:query返回的Observable的輸出是List<String>,在flatMap中變成了參數,而處理過后,返回一個Observable<String>.

假設這時候我們需要處理一下所獲取的結果,我們加個前綴,在保證不修改subscribe的前提下我們可以這么做:

增加個函數,用來增加個前綴:

static Observable<String>addPre(String lan){ return Observable.just("addPre_"+lan);
}

代碼可以這么寫:

query().flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) { return Observable.from(strings);
    }
}).flatMap(new Func1<String, Observable<String>>() {
    @Override
    public Observable<String> call(String s) { //我們在這里調用`addPre`方法,就行處理 return addPre(s);
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

輸出日志

addPre_Java
addPre_Android
addPre_Ruby
addPre_Ios
addPre_Swift

map與flatMap的區別(出自朱凱):

map 是在一個 item 被發射之后，到達 map 處經過轉換變成另一個 item ，然后繼續往下走；
flapMap 是 item 被發射之后，到達 flatMap 處經過轉換變成一個 Observable ，而這個 Observable 并不會直接被發射出去，而是會立即被激活，然后把它發射出的每個 item 都傳入流中，再繼續走下去。
所以 flatMap 和 map 有兩個區別：

1. 經過 Observable 的轉換，相當于重新開了一個異步的流；
2. item 被分散了，個數發生了變化。

這個flatMap還是比較難以理解,它到底是如何工作的.
自己還需要多去了解一下.

更多操作符

1. filter 過濾,把不符合條件的過濾掉,留下符合條件的
2. take 指定最多輸出的數量
3. doOnNext 允許我們在每次輸出一個元素之前做一些額外的事情(其實就是在onNext里調用的)

就用一個例子來演示一下吧:

query().flatMap(new Func1<List<String>, Observable<String>>() {
    @Override
    public Observable<String> call(List<String> strings) { return Observable.from(strings);
    }
}).flatMap(new Func1<String, Observable<String>>() {
    @Override
    public Observable<String> call(String s) { return addPre(s);
    }
}).filter(new Func1<String, Boolean>() {
    @Override
    public Boolean call(String s) { //包含a的留下 return s.contains("a");
    }
}).take(3)//最多只取3個 .doOnNext(new Action1<String>() {
    @Override
    public void call(String s) { //onNext之前 輸出一下 System.out.println("doOnNext:"+s);
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
});

輸出:

doOnNext:addPre_Java
addPre_Java doOnNext:addPre_Android
addPre_Android doOnNext:addPre_Ruby
addPre_Ruby

還有很多很多很多操作符需要去學習,這里就列舉這么幾個.

來自：http://www.jianshu.com/p/88779bda6691