话说通过前三篇文章的讲解，想必你对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。想具体了解的查看这里。
