前面兩篇文章中我們介紹了RxJava的一些基本概念和RxJava最簡單的用法。從這一章開始，我們開始聊聊RxJava中的操作符Operators，RxJava中的操作符主要分成了三類：

1. 轉換類操作符(map flatMap concatMap flatMapIterable switchMap scan groupBy ...)；
2. 過濾類操作符(fileter take takeLast takeUntil distinct distinctUntilChanged skip skipLast ...)；
3. 組合類操作符(merge zip join combineLatest and/when/then
   switch startSwitch ...)。

這一章我們主要講講轉換類操作符。所有這些Operators都作用於一個可觀測序列，然後變換它發射的值，最後用一種新的形式返回它們。概念實在是不好理解，下面我們結合實際的例子一一介紹。

map

map()函數接受一個Func1類型的參數(就像這樣map(Func1<? super T, ? extends R> func)),然後吧這個Func1應用到每一個由Observable發射的值上，將發射的只轉換為我們期望的值。這種狗屁定義我相信你也聽不懂，我們來看一下官方給出的原理圖：

假設我們需要將一組數字裝換成字符串，我們可以通過map這樣實現：

Observable.just(1, 2, 3, 4, 5)
        .map(new Func1<Integer, String>() {
            @Override
            public String call(Integer i) {
                return "This is " + i;
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println(s);
            }
        });
 

Func1構造函數中的兩個參數分別是Observable發射值當前的類型和map轉換後的類型，上面這個例子中發射值當前的類型是Integer,轉換後的類型是String。

flatMap

flatMap()函數同樣也是做轉換的，但是作用卻不一樣。flatMap不開好理解，我們直接看例子（我們公司是個房產平臺，那我就拿房子舉例）：假設我們有一組小區Community[] communites,現在我們要輸出每個小區的名字；我們可以這樣實現:

Observable.from(communities)
        .map(new Func1<Community, String>() {
            @Override
            public String call(Community community) {
                return community.name;
            }
        })
        .subscribe(new Action1<String>() {
            @Override
            public void call(String name) {
                System.out.println("Community name : " + name);
            }
        });

現在我們需求有變化，需要打印出每個小區下面所有房子的價格。於是我可以這樣實現：

Community[] communities = {};
Observable.from(communities)
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                for (House house : community.houses) {
                    System.out.println("House price : " + house.price);
                }
            }
        });

如果我不想在Subscriber中使用for循環，而是希望Subscriber中直接傳入單個的House對象呢（這對於代碼復用很重要）？用map()顯然是不行的，因為map()是一對一的轉化，而我現在的要求是一對多的轉化。那麽我們可以使用flatMap()把一個Community轉化成多個House。

Observable.from(communities)
        .flatMap(new Func1<Community, Observable<House>>() {
            @Override
            public Observable<House> call(Community community) {
                return Observable.from(community.houses);
            }
        })
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                System.out.println("House price : " + house.price);
            }
        });

從前面的例子中你坑定發現了，flatMap()和map()都是把傳入的參數轉化之後返回另一個對象。但和map()不同的是，flatMap()中返回的是Observable對象，並且這個Observable對象並不是被直接發送到 Subscriber的回調方法中。

flatMap()的原理是這樣的：

1. 將傳入的事件對象裝換成一個Observable對象；
2. 這是不會直接發送這個Observable, 而是將這個Observable激活讓它自己開始發送事件；
3. 每一個創建出來的Observable發送的事件，都被匯入同一個Observable，這個Observable負責將這些事件統一交給Subscriber的回調方法。

這三個步驟，把事件拆成了兩級，通過一組新創建的Observable將初始的對象『鋪平』之後通過統一路徑分發了下去。而這個『鋪平』就是flatMap()所謂的flat。

最後我們來看看flatMap的原理圖：

concatMap

concatMap()解決了flatMap()的交叉問題，它能夠把發射的值連續在一起，就像這樣：

flatMapIterable

flatMapIterable()和flatMap()幾乎是一樣的，不同的是flatMapIterable()它轉化的多個Observable是使用Iterable作為源數據的。

Observable.from(communities)
        .flatMapIterable(new Func1<Community, Iterable<House>>() {
            @Override
            public Iterable<House> call(Community community) {
                return community.houses;
            }
        })
        .subscribe(new Action1<House>() {

            @Override
            public void call(House house) {

            }
        });

switchMap

switchMap()和flatMap()很像，除了一點：每當源Observable發射一個新的數據項（Observable）時，它將取消訂閱並停止監視之前那個數據項產生的Observable，並開始監視當前發射的這一個。

scan

scan()對一個序列的數據應用一個函數，並將這個函數的結果發射出去作為下個數據應用合格函數時的第一個參數使用。

我們來看個簡單的例子：

Observable.just(1, 2, 3, 4, 5)
        .scan(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        }).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.print(integer+“ ”);
    }
});

輸出結果為：1 3 6 10 15

groupBy

groupBy()將原始Observable發射的數據按照key來拆分成一些小的Observable，然後這些小Observable分別發射其所包含的的數據，和SQL中的groupBy類似。實際使用中，我們需要提供一個生成key的規則（也就是Func1中的call方法），所有key相同的數據會包含在同一個小的Observable中。另外我們還可以提供一個函數來對這些數據進行轉化，有點類似於集成了flatMap。

單純的文字描述和圖片解釋可能難以理解，我們來看個例子：假設我現在有一組房源List<House> houses,每套房子都屬於某一個小區，現在我們需要根據小區名來對房源進行分類，然後依次將房源信息輸出。

List<House> houses = new ArrayList<>();
houses.add(new House("中糧·海景壹號", "中糧海景壹號新出大平層！總價4500W起"));
houses.add(new House("竹園新村", "滿五唯一，黃金地段"));
houses.add(new House("中糧·海景壹號", "毗鄰湯臣一品"));
houses.add(new House("竹園新村", "頂層戶型，兩室一廳"));
houses.add(new House("中糧·海景壹號", "南北通透，豪華五房"));
Observable<GroupedObservable<String, House>> groupByCommunityNameObservable = Observable.from(houses)
        .groupBy(new Func1<House, String>() {

            @Override
            public String call(House house) {
                return house.communityName;
            }
        });

通過上面的代碼我們創建了一個新的Observable:groupByCommunityNameObservable，它將會發送一個帶有GroupedObservable的序列（也就是指發送的數據項的類型為GroupedObservable）。GroupedObservable是一個特殊的Observable，它基於一個分組的key，在這個例子中的key就是小區名。現在我們需要將分類後的房源依次輸出：

Observable.concat(groupByCommunityNameObservable)
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                System.out.println("小區:"+house.communityName+"; 房源描述:"+house.desc);
            }
        });

執行結果：

小區:中糧·海景壹號; 房源描述:中糧海景壹號新出大平層！總價4500W起
小區:中糧·海景壹號; 房源描述:毗鄰湯臣一品
小區:中糧·海景壹號; 房源描述:南北通透，豪華五房
小區:竹園新村; 房源描述:滿五唯一，黃金地段
小區:竹園新村; 房源描述:頂層戶型，兩室一廳

轉換類的操作符就先介紹到這，後續還會繼續介紹組合、過濾類的操作符及源碼分析，敬請期待！

RxJava系列3(轉換操作符)