RxJava正在Android开发者中变的越来越流行。唯一的问题就是上手不容易，尤其是大部分人之前都是使用命令式编程语言。但是一旦你弄明白了，你就会发现RxJava真是太棒了。
本人目前也正在学习阶段，立此贴来记录自己学习的历程。下来来讲讲RxJava操作符。
操作符
操作符是为了解决对Observable对象的变换的问题，操作符用于在Observable和最终的Subscriber之间修改Observable发出的事件。RxJava提供了很多很有用的操作符。
Subscribers更应该做的事情是“响应”，响应Observable发出的事件，而不是去修改。
所以修改就交给操作符吧.
操作符我按照功能效果进行分类：
创建操作符
just( ) — 将一个或多个对象转换成发射这个或这些对象的一个Observable
from( )— 将一个Iterable, 一个Future, 或者一个数组转换成一个Observable
repeat( )— 创建一个重复发射指定数据或数据序列的Observable
repeatWhen( )— 创建一个重复发射指定数据或数据序列的Observable，它依赖于另一个Observable发射的数据
create( )— 使用一个函数从头创建一个Observable
defer( )— 只有当订阅者订阅才创建Observable；为每个订阅创建一个新的Observable
range( )— 创建一个发射指定范围的整数序列的Observable
interval( )— 创建一个按照给定的时间间隔发射整数序列的Observable
timer( )— 创建一个在给定的延时之后发射单个数据的Observable
empty( )— 创建一个什么都不做直接通知完成的Observable
error( )— 创建一个什么都不做直接通知错误的Observable
never( )— 创建一个不发射任何数据的Observable
变换操作符
map( )— 对序列的每一项都应用一个函数来变换Observable发射的数据序列
flatMap( ), concatMap( ), and flatMapIterable( )— 将Observable发射的数据集合变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable
switchMap( )— 将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据
scan( )— 对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值
groupBy( )— 将Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据
buffer( )— 它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个
window( )— 定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项
cast( )— 在发射之前强制将Observable发射的所有数据转换为指定类型
过滤操作符
filter( )— 过滤数据
takeLast( )— 只发射最后的N项数据
last( )— 只发射最后的一项数据
lastOrDefault( )— 只发射最后的一项数据，如果Observable为空就发射默认值
takeLastBuffer( )— 将最后的N项数据当做单个数据发射
skip( )— 跳过开始的N项数据
skipLast( )— 跳过最后的N项数据
take( )— 只发射开始的N项数据
first( ) and takeFirst( )— 只发射第一项数据，或者满足某种条件的第一项数据
firstOrDefault( )— 只发射第一项数据，如果Observable为空就发射默认值
elementAt( )— 发射第N项数据
elementAtOrDefault( )— 发射第N项数据，如果Observable数据少于N项就发射默认值
sample( ) or throttleLast( )— 定期发射Observable最近的数据
throttleFirst( )— 定期发射Observable发射的第一项数据
throttleWithTimeout( ) or debounce( )— 只有当Observable在指定的时间后还没有发射数据时，才发射一个数据
timeout( )— 如果在一个指定的时间段后还没发射数据，就发射一个异常
distinct( )— 过滤掉重复数据
distinctUntilChanged( )— 过滤掉连续重复的数据
ofType( )— 只发射指定类型的数据
ignoreElements( )— 丢弃所有的正常数据，只发射错误或完成通知
just操作符
创建一个发射指定值的Observable
ust将单个数据转换为发射那个数据的Observable。
Just类似于From，但是From会将数组或Iterable的素具取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据。
注意：如果你传递null
给Just，它会返回一个发射null
值的Observable。不要误认为它会返回一个空Observable（完全不发射任何数据的Observable），如果需要空Observable你应该使用 Empty操作符。
RxJava将这个操作符实现为just
函数，它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。
实例代码：
Observable.just(1, 2, 3)
.subscribe(new Subscriber() {
@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: 2
Next: 3
Sequence complete.
from操作符
将其它种类的对象和数据类型转换为Observable
当你使用Observable时，如果你要处理的数据都可以转换成展现为Observables，而不是需要混合使用Observables和其它类型的数据，会非常方便。这让你在数据流的整个生命周期中，可以使用一组统一的操作符来管理它们。
例如，Iterable可以看成是同步的Observable；Future，可以看成是总是只发射单个数据的Observable。通过显式地将那些数据转换为Observables，你可以像使用Observable一样与它们交互。
因此，大部分ReactiveX实现都提供了将语言特定的对象和数据结构转换为Observables的方法。
在RxJava中，from
操作符可以转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。
实例代码：
myObservable.subscribe(
new Action1() {
@Override
public void call(Integer item) {
System.out.println(item);
}
},
new Action1() {
@Override
public void call(Throwable error) {
System.out.println("Error encountered: " + error.getMessage());
}
},
new Action0() {
@Override
public void call() {
System.out.println("Sequence complete");
}
});
repeat
创建一个发射特定数据重复多次的Observable
Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列，还有一些允许你限制重复的次数。
RxJava将这个操作符实现为repeat
方法。它不是创建一个Observable，而是重复发射原始Observable的数据序列，这个序列或者是无限的，或者通过repeat(n)
指定重复次数。
repeat
操作符默认在trampoline
调度器上执行。有一个变体可以通过可选参数指定Scheduler。
示例代码：
Observable.just(1, 2, 3)
.repeat(3)//重复三次
.subscribe(new Action1() {
@Override
public void call(Integer integer) {
System.out.println("Next: " +integer);
}
});
输出
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 1
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 2
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 3
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 1
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 2
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 3
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 1
12-16 06:52:16.945 3164-3164/? I/System.out: Next: 2
12-16 06:52:16.946 3164-3164/? I/System.out: Next: 3
repeatWhen操作符
还有一个叫做repeatWhen
的操作符，它不是缓存和重放原始Observable的数据序列，而是有条件的重新订阅和发射原来的Observable。
将原始Observable的终止通知（完成或错误）当做一个void
数据传递给一个通知处理器，它以此来决定是否要重新订阅和发射原来的Observable。这个通知处理器就像一个Observable操作符，接受一个发射void
通知的Observable为输入，返回一个发射void
数据（意思是，重新订阅和发射原始Observable）或者直接终止（意思是，使用repeatWhen
终止发射数据）的Observable。
repeatWhen
操作符默认在trampoline
调度器上执行。有一个变体可以通过可选参数指定Scheduler。
Javadoc: repeatWhen(Func1)
Javadoc: repeatWhen(Func1,Scheduler)
doWhile操作符
whileDo属于可选包rxjava-computation-expressions，不是RxJava标准操作符的一部分。whileDo在原始序列的每次重复前检查某个条件，如果满足条件才重复发射。
create操作符
使用一个函数从头开始创建一个Observable
你可以使用Create
操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数让它的行为表现为一个Observable--恰当的调用观察者的onNext，onError和onCompleted方法。
一个形式正确的有限Observable必须尝试调用观察者的onCompleted正好一次或者它的onError正好一次，而且此后不能再调用观察者的任何其它方法。
RxJava将这个操作符实现为 create
方法。
建议你在传递给create
方法的函数中检查观察者的isUnsubscribed
状态，以便在没有观察者的时候，让你的Observable停止发射数据或者做昂贵的运算。
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber observer) {
try {
if (!observer.isUnsubscribed()) {
for (int i = 1; i < 5; i++) {
observer.onNext(i);
}
observer.onCompleted();
}
} catch (Exception e) {
observer.onError(e);
}
}} ).subscribe(new Subscriber() {
@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: 2
Next: 3
Next: 4
Sequence complete.
create
方法默认不在任何特定的调度器上执行。
Javadoc: create(OnSubscribe)
defer操作符
直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable
Defer
操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。
在某些情况下，等待直到最后一分钟（就是知道订阅发生时）才生成Observable可以确保Observable包含最新的数据。
RxJava将这个操作符实现为 defer
方法。这个操作符接受一个你选择的Observable工厂函数作为单个参数。这个函数没有参数，返回一个Observable。
defer
方法默认不在任何特定的调度器上执行。
Javadoc: defer(Func0)
[
](https://github.com/jiang111/RxDocs/blob/master/operators/Defer.md#switchcase)switchCase
可选包 rxjava-computation-expressions
中有一个类似的操作符。switchCase
操作符有条件的创建并返回一个可能的Observables集合中的一个。
可选包 rxjava-computation-expressions
中还有一个更简单的操作符叫ifThen
。这个操作符检查某个条件，然后根据结果，返回原始Observable的镜像，或者返回一个空Observable。
range操作符
创建一个发射特定整数序列的Observable
Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。
RxJava将这个操作符实现为range
函数，它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。
range
默认不在任何特定的调度器上执行。有一个变体可以通过可选参数指定Scheduler。
Javadoc: range(int,int)
Javadoc: range(int,int,Scheduler)
interval操作符
创建一个按固定时间间隔发射整数序列的Observable
Interval
操作符返回一个Observable，它按固定的时间间隔发射一个无限递增的整数序列。
RxJava将这个操作符实现为interval
方法。它接受一个表示时间间隔的参数和一个表示时间单位的参数。
Javadoc: interval(long,TimeUnit)
Javadoc: interval(long,TimeUnit,Scheduler)
还有一个版本的interval
返回一个Observable，它在指定延迟之后先发射一个零值，然后再按照指定的时间间隔发射递增的数字。这个版本的interval
在RxJava 1.0.0中叫做timer
，但是那个方法已经不建议使用了，因为一个名叫interval
的操作符有同样的功能。
Javadoc: interval(long,long,TimeUnit) Javadoc: interval(long,long,TimeUnit,Scheduler)
interval
默认在computation
调度器上执行。你也可以传递一个可选的Scheduler参数来指定调度器。
timer操作符
创建一个Observable，它在一个给定的延迟后发射一个特殊的值。
Timer
操作符创建一个在给定的时间段之后返回一个特殊值的Observable。
RxJava将这个操作符实现为timer
函数。
timer
返回一个Observable，它在延迟一段给定的时间后发射一个简单的数字0。
timer
操作符默认在computation
调度器上执行。有一个变体可以通过可选参数指定Scheduler。
Javadoc: timer(long,TimeUnit)
Javadoc: timer(long,TimeUnit,Scheduler)
empty操作符
创建一个不发射任何数据但是正常终止的Observable
[
](https://github.com/jiang111/RxDocs/blob/master/operators/Empty.md#never)Never
创建一个不发射数据也不终止的Observable
[
](https://github.com/jiang111/RxDocs/blob/master/operators/Empty.md#throw)Throw
创建一个不发射数据以一个错误终止的Observable
这三个操作符生成的Observable行为非常特殊和受限。测试的时候很有用，有时候也用于结合其它的Observables，或者作为其它需要Observable的操作符的参数。
RxJava将这些操作符实现为 empty
，never
和error
。error
操作符需要一个Throwable
参数，你的Observable会以此终止。这些操作符默认不在任何特定的调度器上执行，但是empty
和error
有一个可选参数是Scheduler，如果你传递了Scheduler参数，它们会在这个调度器上发送通知。
Javadoc: empty()
Javadoc: never()
Javadoc: error(java.lang.Throwable)