話說通過前三篇文章的講解，想必你對RxJava也有了深刻的認識吧，啥，你說沒有？那回去看看！那么今天我們來分析RxJava最牛逼的地方。睜大眼睛看看哦，不管你濕沒濕，反正我已經濕了。
一、API
RxJava提供了對事件序列進行變換的支持，這是它的核心功能之一，也是大多數人說RxJava好用的最大原因。所謂變換，就是將事件序列中的對象或整個序列進行加工處理，轉換成不同的事件或事件序列。
首先看一個<code>map()</code>的例子：
Observable.just("images/logo.png") // 輸入類型 String
.map(new Func1<String, Bitmap>() {
@Override
public Bitmap call(String filePath) { // 參數類型 String
return getBitmapFromPath(filePath); // 返回類型 Bitmap
}
})
.subscribe(new Action1<Bitmap>() {
@Override
public void call(Bitmap bitmap) { // 參數類型 Bitmap
showBitmap(bitmap);
}
});
這里出現了一個叫做 Func1的類。它和 Action1非常相似，也是 RxJava 的一個接口，用于包裝含有一個參數的方法。 Func1和Action的區別在于， Func1包裝的是有返回值的方法。另外，和 ActionX一樣， FuncX也有多個，用于不同參數個數的方法。FuncX和 ActionX的區別在 FuncX包裝的是有返回值的方法。
可以看到，<code>map()</code>方法將參數中的<code>String</code>對象轉換成了一個Bitmap對象后返回，經過<code>map()</code>方法后，事件的參數類型也由<code>String</code>轉為<code>Bitmap</code>。這種直接變換對象并返回的，就是最常見的變換。不過RxJava的變換遠不止這樣，它不僅可以針對事件對象，還可以針對整個事件隊列，是不是好屌的樣子啊？
- <code>map()</code>:事件對象的直接變換。示意圖如下
- <code>flatMap()</code>:FlatMap將一個發射數據的Observable變換為多個Observables，然后將它們發射的數據合并后放進一個單獨的Observable.
這是一個很有用但非常難理解的變換，因此我決定花多些篇幅來介紹它。 首先假設這么一種需求：假設有一個數據結構『學生』，現在需要打印出一組學生的名字。實現方式很簡單：
Student[] students = ...;
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onNext(String name) {
Log.d(tag, name);
}
...
};
Observable.from(students)
.map(new Func1<Student, String>() {
@Override
public String call(Student student) {
return student.getName();
}
})
.subscribe(subscriber);
很簡單。那么再假設：如果要打印出每個學生所需要修的所有課程的名稱呢？（需求的區別在于，每個學生只有一個名字，但卻有多個課程。）首先可以這樣實現：
Student[] students = ...;
Subscriber<Student> subscriber = new Subscriber<Student>() {
@Override
public void onNext(Student student) {
List<Course> courses = student.getCourses();
for (int i = 0; i < courses.size(); i++) {
Course course = courses.get(i);
Log.d(tag, course.getName());
}
}
...
};
Observable.from(students)
.subscribe(subscriber);
依然很簡單。那么如果我不想在 Subscriber中使用 for 循環，而是希望 Subscriber中直接傳入單個的 Course對象呢（這對于代碼復用很重要）？用 map()顯然是不行的，因為 map()是一對一的轉化，而我現在的要求是一對多的轉化。那怎么才能把一個 Student 轉化成多個 Course 呢？這個時候就要用flatMap()了：
Student[] students = ...;
Subscriber<Course> subscriber = new Subscriber<Course>() {
@Override
public void onNext(Course course) {
Log.d(tag, course.getName());
}
...
};
Observable.from(students)
.flatMap(new Func1<Student, Observable<Course>>() {
@Override
public Observable<Course> call(Student student) {
return Observable.from(student.getCourses());
}
})
.subscribe(subscriber);
從上面看出，<code>flatMap()</code>和<code>map()</code>有一個共同點：它也是把傳入的參數轉化之后返回另一個對象。但不同的是，<code>flatMap()</code>返回的是<code>Observable</code>對象,并且這個<code>Observable</code>對象并不是直接發給<code>Subscriber</code>的回調方法中。
flatMap()的原理是這樣的：
1. 使用傳入的事件對象創建一個 Observable對象；
2. 并不發送這個 Observable, 而是將它激活，于是它開始發送事件；
3. 每一個創建出來的 Observable 發送的事件，都被匯入同一個 Observable，而這個 Observable 負責將這些事件統一交給 Subscriber的回調方法。
這三個步驟，把事件拆成了兩級，通過一組新創建 Observable將初始的對象『鋪平』之后通過統一路徑分發了下去。而這個『鋪平』就是 flatMap() 所謂的 flat。
<code>flatMap()</code>示意圖：
二、變換的原理：lift()
這些變換雖然功能各有不同，但實質上都是針對事件序列的處理和再發送。而在 RxJava 的內部，它們是基于同一個基礎的變換方法：<code>lift(Operator)</code>。首先看一下 <code>lift()</code> 的內部實現（僅核心代碼）
// 注意：這不是 lift() 的源碼，而是將源碼中與性能、兼容性、擴展性有關的代碼剔除后的核心代碼。
// 如果需要看源碼，可以去 RxJava 的 GitHub 倉庫下載。
public <R> Observable<R> lift(Operator<? extends R, ? super T> operator) {
return Observable.create(new OnSubscribe<R>() {
@Override
public void call(Subscriber subscriber) {
Subscriber newSubscriber = operator.call(subscriber);
newSubscriber.onStart();
onSubscribe.call(newSubscriber);
}
});
}
它生成一個新的<code>Observable</code>并返回，而且創建新<code>Observable</code>所用的參數<code>OnSubscribe</code>的回調方法<code>call()</code>
中實現竟然看起來和前面講的<code>Observable.subscribe()</code>一樣！然而它們并不一樣喲~不一樣的地方關鍵就在于第二行onSubscribe.call(subscriber)中的 onSubscribe所指代的對象不同。
*subscribe()中的 onSubscribe指的是 Observable中的 onSubscribe對象，這個沒有問題，但是 lift()之后的情況就復雜了點。
*當含有lift()時：
1、<code>lift()</code>創建了一個Observable后，加上之前原始的Observable，已經有兩個Observable對象了.
2、同樣，新Observable里的OnSubscribe加上原始的OnSubscribe，也有兩個OnSubscribe;
3、當調用lift()后的subscribe()時，使用的是lift()所返回的新Observable,于是它被所觸發的onSubscribe.call(subscriber)也是新Observable中的OnSubscribe;
4、新OnSubscribe的call()方法中的onSubscribe，就是指原始Observable中的OnSubscribe.在這個 call()方法里，新 OnSubscribe 利用 operator.call(subscriber)
生成了一個新的 Subscriber（Operator 就是在這里，通過自己的call() 方法將新 Subscriber 和原始 Subscriber 進行關聯，并插入自己的『變換』代碼以實現變換），然后利用這個新Subscriber 向原始 Observable進行訂閱。
這樣就實現了 lift()過程，有點像一種代理機制，通過事件攔截和處理實現事件序列的變換。
精簡掉細節的話，也可以這么說：在 Observable 執行了 lift(Operator) 方法之后，會返回一個新的 Observable，這個新的Observable會像一個代理一樣，負責接收原始的 Observable發出的事件，并在處理后發送給 Subscriber。
同時可以看圖：
此外，RxJava提供很多變化操作符如Buffer、FlatMap、Map、GroupBy、Scan、Window。想具體了解的查看這里。
