RXJAVA操作符

Creating Observables(Observable的创建操作符)，比如：Observable.create()、Observable.just()、Observable.from()等等；
Transforming Observables(Observable的转换操作符)，比如：observable.map()、observable.flatMap()、observable.buffer()等等；
Filtering Observables(Observable的过滤操作符)，比如：observable.filter()、observable.sample()、observable.take()等等；
Combining Observables(Observable的组合操作符)，比如：observable.join()、observable.merge()、observable.combineLatest()等等；
Error Handling Operators(Observable的错误处理操作符)，比如:observable.onErrorResumeNext()、observable.retry()等等；
Observable Utility Operators(Observable的功能性操作符)，比如：observable.subscribeOn()、observable.observeOn()、observable.delay()等等；
Conditional and Boolean Operators(Observable的条件操作符)，比如：observable.amb()、observable.contains()、observable.skipUntil()等等；
Mathematical and Aggregate Operators(Observable数学运算及聚合操作符)，比如：observable.count()、observable.reduce()、observable.concat()等等；

其他如observable.toList()、observable.connect()、observable.publish()等等；

timer操作符，它的意思是延迟执行某个操作；
map操作符，它的意思是转换某个执行结果；
mergeDelayError，它的意思是合并几个不同的Observable；
subscribeOn(Schedulers.io())启动IO流线程；
sample的意思是每隔一段时间就进行采样，在时间间隔范围内获取最后一个发布的Observable； 
sample(2, TimeUnit.SECONDS, AndroidSchedulers.mainThread())每隔两秒获取加载数据，运行在主线程；
flatMap的意思是把某一个Observable转换成另一个Observable；

Create操作符例子

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.

from操作符，from操作符是把其他类型的对象和数据类型转化成Observable，其案例如下

Integer[] items = { 0, 1, 2, 3, 4, 5 };
Observable myObservable = Observable.from(items);
myObservable.subscribe(
    new Action1<integer>() {
        @Override
        public void call(Integer item) {
            System.out.println(item);
        }
    },
    new Action1<throwable>() {
        @Override
        public void call(Throwable error) {
            System.out.println("Error encountered: " + error.getMessage());
        }
    },
    new Action0() {
        @Override
        public void call() {
            System.out.println("Sequence complete");
        }
    }
);</throwable></integer></code>

运行结果如下：
0
1
2
3
4
5
Sequence complete

just操作符也是把其他类型的对象和数据类型转化成Observable，它和from操作符很像，只是方法的参数有所差别，其案例如下：

 Observable.just(1, 2, 3)
          .subscribe(new Subscriber<integer>() {
        @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.

defer操作符是直到有订阅者订阅时，才通过Observable的工厂方法创建Observable并执行，defer操作符能够保证Observable的状态是最新的，其案例如下：
下面通过比较defer操作符和just操作符的运行结果作比较：

i=10;
        Observable justObservable = Observable.just(i);
        i=12;
        Observable deferObservable = Observable.defer(new Func0<observable<cke:object>>() {
            @Override
            public Observable<object> call() {
                return Observable.just(i);
            }
        });
        i=15;
 
        justObservable.subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onNext(Object o) {
                System.out.println("just result:" + o.toString());
            }
        });
 
        deferObservable.subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onNext(Object o) {
                System.out.println("defer result:" + o.toString());
            }
        });
   }

其中i是类的成员变量，运行结果如下：
just result:10
defer result:15

可以看到，just操作符是在创建Observable就进行了赋值操作，而defer是在订阅者订阅时才创建Observable，此时才进行真正的赋值操作。

timer操作符是创建一串连续的数字，产生这些数字的时间间隔是一定的；这里有两种情况：
一种是隔一段时间产生一个数字，然后就结束，可以理解为延迟产生数字，
另一种是每隔一段时间就产生一个数字，没有结束符，也就是是可以产生无限个连续的数字：
timer操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。

<code class="hljs cs">
        //每隔两秒产生一个数字
        Observable.timer(2, 2, TimeUnit.SECONDS).subscribe(new Subscriber<long>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("error:" + e.getMessage());
            }
 
            @Override
            public void onNext(Long aLong) {
                System.out.println("Next:" + aLong.toString());
            }
        });</long></code>

运行结果如下：
Next:0
Next:1
Next:2
Next:3
……

interval操作符
interval操作符是每隔一段时间就产生一个数字，这些数字从0开始，一次递增1直至无穷大；
interval操作符的实现效果跟上面的timer操作符的第二种情形一样：
interval操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。
调用例子就不列出了，基本跟上面timer的调用例子一样。

range操作符是创建一组在从n开始，个数为m的连续数字，比如range(3,10)，就是创建3、4、5…12的一组数字：

<code class="hljs cs">//产生从3开始，个数为10个的连续数字
        Observable.range(3,10).subscribe(new Subscriber<integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("error:" + e.getMessage());
            }
 
            @Override
            public void onNext(Integer i) {
                System.out.println("Next:" + i.toString());
            }
        });</integer></code>

运行结果如下：
Next:3
Next:4
Next:5
Next:6
….
Next:12
Sequence complete.

repeat/repeatWhen操作符
repeat操作符是对某一个Observable，重复产生多次结果：
repeatWhen操作符是对某一个Observable，有条件地重新订阅从而产生多次结果：
repeat和repeatWhen操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。
repeat的例子：

<code class="hljs cs">//连续产生两组(3,4,5)的数字
        Observable.range(3,3).repeat(2).subscribe(new Subscriber<integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            public void onError(Throwable e) {
                System.out.println("error:" + e.getMessage());
            }
 
            @Override
            public void onNext(Integer i) {
                System.out.println("Next:" + i.toString());
            }
        });</integer></code>

运行结果如下：
Next:3
Next:4
Next:5
Next:3
Next:4
Next:5
Sequence complete.