RxJava的辅助操作符实例

辅助操作符

RxJava提供很多的辅助操作符，帮助我们更好的堆Observable进行更加方便的操作。

meterailize/Dematerialize 操作符

meterailize操作符被一个合法有限的Observable调用的时候，如果Observable调用Observer的onNext次数为0或者多次，omComplete次数为1次，或者onError1次。meterailize会将不管是onNext还是onComplete还是onError包装成为Observable发射，而Dematerialize的作用则是相反。meterailize使用的时候他会包装Observable的数据源为一个Notification类型再去传递，例子：

   Observable.range(10,3).map(new Func1<Integer, Notification<Integer>>() {
            @Override
            public Notification<Integer> call(Integer integer) {
                return Notification.createOnNext(integer);
            }
        }).materialize().subscribe(new Observer<Notification<Notification<Integer>>>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError"+e.getMessage());
            }

            @Override
            public void onNext(Notification<Notification<Integer>> notification) {
                Log.i(TAG, "materialize"+notification);
            }
        });

输出就是：

10-27 16:35:43.962 4606-4606/com.example.user.testproject I/RxJavaTest: materialize[rx.Notification@26788166 OnNext [rx.Notification@133c40b8 OnNext 10]]
10-27 16:35:43.963 4606-4606/com.example.user.testproject I/RxJavaTest: materialize[rx.Notification@26788167 OnNext [rx.Notification@133c40b9 OnNext 11]]
10-27 16:35:43.963 4606-4606/com.example.user.testproject I/RxJavaTest: materialize[rx.Notification@26788168 OnNext [rx.Notification@133c40ba OnNext 12]]
10-27 16:35:43.963 4606-4606/com.example.user.testproject I/RxJavaTest: materialize[rx.Notification@df4db0e OnCompleted]
10-27 16:35:43.963 4606-4606/com.example.user.testproject I/RxJavaTest: onCompleted

可以看到他是多了一个omCompleted事件的，但是这个传递到onNexu的时候他的值是为null的，所以使用的时候注意。
假如是使用Dematerialize操作符，他是把materialize数据源包装的Notification还原回去，例如：

Observable.range(10, 3).map(new Func1<Integer, Notification<Integer>>() {
            @Override
            public Notification<Integer> call(Integer integer) {
                return Notification.createOnNext(integer);
            }
        }).dematerialize().subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e.getMessage());
            }

            @Override
            public void onNext(Object notification) {
                Log.i(TAG, "dematerialize = " + notification);
            }
        });

输出是：

10-27 16:42:13.563 10276-10276/? I/RxJavaTest: dematerialize = 10
10-27 16:42:13.564 10276-10276/? I/RxJavaTest: dematerialize = 11
10-27 16:42:13.564 10276-10276/? I/RxJavaTest: dematerialize = 12
10-27 16:42:13.564 10276-10276/? I/RxJavaTest: onCompleted

还把最后一个空的过滤了。
图片：

delay 操作符

延迟发射Observable。

 Observable<T> delay(long delay, TimeUnit unit)

该方法会延时整一个observable，但是延时结束之后会立马开始发射，之后的数据将不会再延时(同时，以下的其他操作符也是基于这个observable的)例如：

 Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i(TAG, "发射");
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                subscriber.onCompleted();
            }
        });

        observable.delay(2, TimeUnit.SECONDS).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, "delay= " + s);
            }
        });

输出：

10-30 16:12:58.535 3044-3044/com.example.user.testproject I/RxJavaTest: 发射
10-30 16:13:00.537 3044-3070/com.example.user.testproject I/RxJavaTest: delay= A
10-30 16:13:00.538 3044-3070/com.example.user.testproject I/RxJavaTest: delay= B
10-30 16:13:00.538 3044-3070/com.example.user.testproject I/RxJavaTest: delay= C
10-30 16:13:00.538 3044-3070/com.example.user.testproject I/RxJavaTest: onCompleted

需要注意的是：
当第一个发射的就是onError的时候，该延时将不会起效，立马就会发射给Observer，但是假如是发射onComplete的时候还是会延时的。

<U> Observable<T> delay(Func1<? super T, ? extends Observable<U>> itemDelay)

他可以给给一个Observable给定一个延时，当Func1返回的Observable发射的时候，源数据对应的数据就会发射，比如：

observable.delay(2, TimeUnit.SECONDS);
        observable.delay(new Func1<String, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(String s) {
                if ("A".equals(s)) {
                    return Observable.just(1)
                            .delay(1, TimeUnit.SECONDS);
                }else {
                    return Observable.just(1)
                            .delay(2, TimeUnit.SECONDS);
                }

            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, "delay= " + s);
            }
        });

结果“

10-30 16:31:12.929  发射
10-30 16:31:13.955 delay= A
10-30 16:31:14.956  delay= B
10-30 16:31:14.958  delay= C
10-30 16:31:14.959 onCompleted

这里，A是延时了1s发射，但是其他的数据是延时了约2s发射。注意的是他不是有叠加的效果，不会是让上一个Observable发射了之后再去延时下一个。
图：

delaySubscription 操作符

他是延迟Observable中OnSubscribe调用call的时间

 <U> Observable<T> delaySubscription(Func0<? extends Observable<U>> subscriptionDelay)

他根据Func0返回的Observable延迟Observable和Observer之间关联，例如

 observable.delaySubscription(new Func0<Observable<String>>() {
            @Override
            public Observable<String> call() {
                Log.i(TAG, "延时订阅开始" );
                return Observable.just("A").delay(2,TimeUnit.SECONDS);
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "delaySubscription = " + s);
            }
        });

输出：

10-30 16:42:28.510 28979-28979/com.example.user.testproject I/RxJavaTest: 延时订阅开始
10-30 16:42:30.530 28979-29003/com.example.user.testproject I/RxJavaTest: 发射
10-30 16:42:30.530 28979-29003/com.example.user.testproject I/RxJavaTest: delaySubscription = A
10-30 16:42:30.530 28979-29003/com.example.user.testproject I/RxJavaTest: delaySubscription = B
10-30 16:42:30.530 28979-29003/com.example.user.testproject I/RxJavaTest: delaySubscription = C

可以看到延时开始后之后是经过了约2s的时间之后才发生了订阅的关系。
重载函数：

 public final Observable<T> delaySubscription(long delay, TimeUnit unit) 

该函数的作用也是类似的。
图：

do系列操作符

doOnEach

Observable<T> doOnEach(final Action1<Notification<? super T>> onNotification)

他提供一个Action1的谓词，用于在Observable发射的时候同时也被转换成一个Notification，该Notification中携带了被发射的value，相当于可以多个Observer被调用，例子：

  observable.doOnEach(new Action1<Notification<? super String>>() {
            @Override
            public void call(Notification<? super String> notification) {
                Log.i(TAG, "notification = " + notification.getValue());
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "doOnEach = " + s);
            }
        });

输出：

10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: notification = A
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: doOnEach = A
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: notification = B
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: doOnEach = B
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: notification = C
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: doOnEach = C
10-31 15:31:40.565 2396-2396/com.example.user.testproject I/RxJavaTest: notification = null

其中最后一个是null代表的onComplete函数被调用。
重载函数：

Observable<T> doOnEach(Observer<? super T> observer)

他的作用也是类似的，只不过doOnEach参数中的observer的onNext，onComplete,onError也是同样会被调用，例如：

observable.doOnEach(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted" );
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError = " + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, "doOnEach = " + s);
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "subscribe = " + s);
            }
        });

输出：

10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: doOnEach = A
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: subscribe = A
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: doOnEach = B
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: subscribe = B
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: doOnEach = C
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: subscribe = C
10-31 15:34:05.038 4612-4612/com.example.user.testproject I/RxJavaTest: onCompleted

图：

doOnNext

Observable<T> doOnNext(final Action1<? super T> onNext)

他的作用只是会回调被发射源数据的onNext函数而不是全部，例如:

 observable.doOnNext(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "doOnNext = " + s);
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "subscribe = " + s);
            }
        });

输出：

10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: doOnNext = A
10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: subscribe = A
10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: doOnNext = B
10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: subscribe = B
10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: doOnNext = C
10-31 15:36:34.501 6801-6801/com.example.user.testproject I/RxJavaTest: subscribe = C

图：

doOnSubscribe操作符

Observable<T> doOnSubscribe(final Action0 subscribe)

操作符注册一个动作，当观察者订阅它生成的Observable它就会被调用。例如：

observable.doOnSubscribe(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnSubscribe被调用" );
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "subscribe = " + s);
            }
        });

输出：

10-31 15:39:23.039 9254-9254/com.example.user.testproject I/RxJavaTest: doOnSubscribe被调用
10-31 15:39:23.039 9254-9254/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:39:23.039 9254-9254/com.example.user.testproject I/RxJavaTest: subscribe = A
10-31 15:39:23.039 9254-9254/com.example.user.testproject I/RxJavaTest: subscribe = B
10-31 15:39:23.039 9254-9254/com.example.user.testproject I/RxJavaTest: subscribe = C

适合做一些在发射数据之前的操作。图：

doOnUnsubscribe操作符

Observable<T> doOnUnsubscribe(final Action0 unsubscribe)

当观察者取消订阅它生成的Observable它就会被调用，比如调用了onComplete函数或者是Observer和Observa之间取消了关联的时候被调用，例如：

observable.doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnUnsubscribe" );
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "subscribe = " + s);
            }
        });

输出：

10-31 15:41:26.559 11057-11057/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:41:26.559 11057-11057/com.example.user.testproject I/RxJavaTest: subscribe = A
10-31 15:41:26.559 11057-11057/com.example.user.testproject I/RxJavaTest: subscribe = B
10-31 15:41:26.559 11057-11057/com.example.user.testproject I/RxJavaTest: subscribe = C
10-31 15:41:26.559 11057-11057/com.example.user.testproject I/RxJavaTest: doOnUnsubscribe

适合做一些收尾的工作，图：

doOnCompleted和doOnError操作符

Observable<T> doOnCompleted(final Action0 onCompleted)
 Observable<T> doOnError(final Action1<Throwable> onError) 

会在Observa调用对应的函数之前被调用。注意是之前被调用，例如：

  observable.doOnCompleted(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnCompleted " );
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "subscribe = " + s);
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.i(TAG, "throwable " + throwable.getMessage());
            }
        }, new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "Completed ");
            }
        });

正常结束的时候结果是：

10-31 15:47:59.653 16908-16908/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:47:59.653 16908-16908/com.example.user.testproject I/RxJavaTest: subscribe = A
10-31 15:47:59.653 16908-16908/com.example.user.testproject I/RxJavaTest: subscribe = B
10-31 15:47:59.653 16908-16908/com.example.user.testproject I/RxJavaTest: subscribe = C
10-31 15:47:59.653 16908-16908/com.example.user.testproject I/RxJavaTest: doOnCompleted
10-31 15:47:59.653 16908-16908/com.example.user.testproject I/RxJavaTest: Completed 

把observable最后调用改为：

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i(TAG, "发射");
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
//                subscriber.onCompleted();
                subscriber.onError(new IllegalArgumentException("error"));
            }
        });

  observable.doOnError(new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.i(TAG, "doOnError = " + throwable.getMessage());
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "subscribe = " + s);
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.i(TAG, "throwable " + throwable.getMessage());
            }
        }, new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "Completed ");
            }
        });

输出是：

10-31 15:52:01.173 20513-20513/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:52:01.173 20513-20513/com.example.user.testproject I/RxJavaTest: subscribe = A
10-31 15:52:01.173 20513-20513/com.example.user.testproject I/RxJavaTest: subscribe = B
10-31 15:52:01.173 20513-20513/com.example.user.testproject I/RxJavaTest: subscribe = C
10-31 15:52:01.173 20513-20513/com.example.user.testproject I/RxJavaTest: doOnError = error
10-31 15:52:01.173 20513-20513/com.example.user.testproject I/RxJavaTest: throwable error

图：

doOnTerminate操作符

在Observable发射终止之前调用，无论是正常还是错误的结束，就是相当于doOnCompleted和doOnError两个的结合体
例子就不写了，图：

doAfterTerminate操作符

在Observable终止之后会被调用，也就是在操作符doOnTerminate之后被调用，在doOnUnsubscribe之后被调用
图：

finallyDo操作符

该操作符已经被废弃，但是他的作用是当它产生的Observable终止之后会被调用，无论是正常还是异常终止。会在doOnUnsubscribe操作调用之后调用，例如：

 observable.finallyDo(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "finallyDo ");
            }
        }).doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnUnsubscribe ");
            }
        }).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {

            }
        });

输出：

10-31 15:58:56.166 26661-26661/com.example.user.testproject I/RxJavaTest: 发射
10-31 15:58:56.166 26661-26661/com.example.user.testproject I/RxJavaTest: doOnUnsubscribe
10-31 15:58:56.166 26661-26661/com.example.user.testproject I/RxJavaTest: finallyDo 

图：

serialize操作符

Observable<T> serialize() 

他的作用主要是维持保证Observable能够正常的结束调用。比如，由于我们的Observable发射数据的时候可能是异步的，那么他们就存在着一种这样子的关系：我前面的数据正常调用onNext函数，然后在某一个异步中调用onComplete函数需要正常结束掉这个Observable，但是还有一些没有完成的异步任务，他们完成之后还会调用onNext函数，但是这回导致Observable的调用不正确，我们需要维持这个Observable正常结束，就可以使用serialize。例如

Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                subscriber.onCompleted();
                subscriber.onNext("D");
                subscriber.onCompleted();

            }
        });

        ob.doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnUnsubscribe");
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, "s");
            }
        });

这时候的输出是正常的，是：

11-01 14:01:36.273 8186-8186/? I/RxJavaTest: A
11-01 14:01:36.273 8186-8186/? I/RxJavaTest: B
11-01 14:01:36.273 8186-8186/? I/RxJavaTest: C
11-01 14:01:36.273 8186-8186/? I/RxJavaTest: onCompleted
11-01 14:01:36.273 8186-8186/? I/RxJavaTest: doOnUnsubscribe

这是正常的原因是Observer接受到onComplete的时候结束掉了订阅的关系，但是当我们使用unsafeSubscribe操作符，该操作符不会使得Observer主动结束订阅关系的时候去订阅Observable的例子：

 ob.doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnUnsubscribe");
            }
        }).unsafeSubscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, "s");
            }
        });

输出的结果是：

11-01 14:01:01.290 7672-7672/com.example.user.testproject I/RxJavaTest: A
11-01 14:01:01.290 7672-7672/com.example.user.testproject I/RxJavaTest: B
11-01 14:01:01.290 7672-7672/com.example.user.testproject I/RxJavaTest: C
11-01 14:01:01.290 7672-7672/com.example.user.testproject I/RxJavaTest: onCompleted
11-01 14:01:01.290 7672-7672/com.example.user.testproject I/RxJavaTest: D
11-01 14:01:01.290 7672-7672/com.example.user.testproject I/RxJavaTest: onCompleted

可以看到他是没有正常结束的，应该是发射了C之后就结束的，同时也没有调用unsafeSubscribe函数，这时候我们需要维持正常，就可以使用serialize谓词，例如：

ob.doOnUnsubscribe(new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "doOnUnsubscribe");
            }
        }).serialize().subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG,s);
            }
        });

输出结果：

11-01 14:03:08.302 9525-9525/com.example.user.testproject I/RxJavaTest: A
11-01 14:03:08.302 9525-9525/com.example.user.testproject I/RxJavaTest: B
11-01 14:03:08.302 9525-9525/com.example.user.testproject I/RxJavaTest: C
11-01 14:03:08.302 9525-9525/com.example.user.testproject I/RxJavaTest: onCompleted
11-01 14:03:08.302 9525-9525/com.example.user.testproject I/RxJavaTest: doOnUnsubscribe

这时候看到的是正常结束了。
图：

ObserveOn操作符

Observable<T> observeOn(Scheduler scheduler)
Observable<T> observeOn(Scheduler scheduler, int bufferSize)
Observable<T> observeOn(Scheduler scheduler, boolean delayError)

该操作符用于指定Observer在那个调度器上面去观察Observable，也就是Observable发射数据之后，在Observer中处理时候的线程。例如：

Log.i(TAG, Thread.currentThread().getName());
        Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i(TAG, "Observable"+Thread.currentThread().getName());
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                subscriber.onCompleted();
            }
        });
        ob.observeOn(Schedulers.newThread()).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
                Log.i(TAG, "Observer=" + Thread.currentThread().getName());
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {

            }
        }, new Action0() {
            @Override
            public void call() {
                Log.i(TAG, "Complete");
                Log.i(TAG, "Observer=" + Thread.currentThread().getName());
            }
        });

输出结果：

11-01 14:30:00.235 882-882/com.example.user.testproject I/RxJavaTest: main
11-01 14:30:00.263 882-882/com.example.user.testproject I/RxJavaTest: Observablemain
11-01 14:30:00.264 882-910/com.example.user.testproject I/RxJavaTest: A
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: B
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: C
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: Complete
11-01 14:30:00.267 882-910/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1

可以看到Observer处理的线程就是我们通过observeOn操作符给他定义的线程
图：

SubscribeOn操作符

Observable<T> subscribeOn(Scheduler scheduler)

用于指定Observable运行call的时候的线程，或者说是Observable自身所在的线程。例如：

 Log.i(TAG, Thread.currentThread().getName());
        Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i(TAG, "Observable = "+Thread.currentThread().getName());
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread()).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "Observer=" + Thread.currentThread().getName());
            }
        });

输出：

11-01 14:33:03.439 3927-3927/com.example.user.testproject I/RxJavaTest: main
11-01 14:33:03.500 3927-3952/com.example.user.testproject I/RxJavaTest: Observable = RxNewThreadScheduler-1
11-01 14:33:03.500 3927-3952/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1
11-01 14:33:03.501 3927-3952/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1
11-01 14:33:03.501 3927-3952/com.example.user.testproject I/RxJavaTest: Observer=RxNewThreadScheduler-1

可以看到Observable所在的线程是我们给他指定的线程，Observer默认不在任何调度器上面执行，所以也跟着在这个线程上面执行，我们可以这样子指定：

 Log.i(TAG, Thread.currentThread().getName());
        Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                Log.i(TAG, "Observable = "+Thread.currentThread().getName());
                subscriber.onNext("A");
                subscriber.onNext("B");
                subscriber.onNext("C");
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, "Observer=" + Thread.currentThread().getName());
            }
        });

这样子Observer就可以在指定的不用于Observable所在的线程，注意这里需要引入RxAdnroid。
图：

subscribe操作符

Subscription subscribe() //只是需要让Observable和Observer发生关联，不需要处理Observable发射的数据
Subscription subscribe(final Action1<? super T> onNext);// 只是接受OnNext数据
Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError)// 只是接受onNext和onError数据
Subscription subscribe(final Action1<? super T> onNext, final Action1<Throwable> onError, final Action0 onCompleted)// 接受全部事件数据
Subscription subscribe(final Observer<? super T> observer)// 作用跟上面的类似，可以处理所有Observable发射的事件数据。

就是平常我们使用最多的一个操作符，用于关联Observable和Observer。他的例子就不写了。
图：

timeInterval操作符

Observable<TimeInterval<T>> timeInterval()
Observable<TimeInterval<T>> timeInterval(Scheduler scheduler)

他的作用是把源Observable发射的数据T装换为一个TimeInterval对象，存储有他的值和该源数据跟前一个Observable数据发射的时间间隔。
例如:

 Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 1; i < 5; i++) {
                    subscriber.onNext("" + i);
                    try {
                        Thread.sleep(i * 100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread()).timeInterval().map(new Func1<TimeInterval<String>, String>() {
            @Override
            public String call(TimeInterval<String> time) {
                Log.i(TAG, "前后相差时间：" + time.getIntervalInMilliseconds()+"  值："+time.getValue());
                return time.getValue();
            }
        }).subscribe();

结果输出：

11-01 14:53:02.878 21735-21749/? I/RxJavaTest: 前后相差时间：2  值：1
11-01 14:53:02.980 21735-21749/? I/RxJavaTest: 前后相差时间：102  值：2
11-01 14:53:03.182 21735-21749/? I/RxJavaTest: 前后相差时间：202  值：3
11-01 14:53:03.483 21735-21749/? I/RxJavaTest: 前后相差时间：301  值：4

图：

Timeout操作符

第一种：

Observable<T> timeout(long timeout, TimeUnit timeUnit)
Observable<T> timeout(long timeout, TimeUnit timeUnit, Scheduler scheduler)

该操作符在两个Observable数据发射之前的时间间隔超出了timeout，就会发射一个TimeoutException给Observer的onError。例如：

Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                for (int i=1;i<=4;i++) {
                    try {
                        Thread.sleep(i * 200);
                        subscriber.onNext("" + i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.currentThread().sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext("B");
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread()).timeout(1,TimeUnit.SECONDS).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError"+e);
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        });

输出结果：

11-01 15:20:03.978 13695-13710/? I/RxJavaTest: A
11-01 15:20:04.181 13695-13710/? I/RxJavaTest: 1
11-01 15:20:04.583 13695-13710/? I/RxJavaTest: 2
11-01 15:20:05.183 13695-13710/com.example.user.testproject I/RxJavaTest: 3
11-01 15:20:05.984 13695-13710/com.example.user.testproject I/RxJavaTest: 4
11-01 15:20:06.985 13695-13709/com.example.user.testproject I/RxJavaTest: onErrorjava.util.concurrent.TimeoutException

从这里可以看到是两个Observable数据发射的时间间隔，而不是总体的发射时间。

第二种：

 Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other)
Observable<T> timeout(long timeout, TimeUnit timeUnit, Observable<? extends T> other, Scheduler scheduler)

这个函数可以在超时之后发射一个Observable座位补充，他是接着在源的数据之后发射，例如：

  Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                for (int i = 1; i <= 4; i++) {
                    try {
                        Thread.sleep(i * 200);
                        subscriber.onNext("" + i);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                try {
                    Thread.currentThread().sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext("B");
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread()).timeout(1, TimeUnit.SECONDS, Observable.just("G")).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e);
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        });

输出：

11-01 15:25:24.379 18453-18468/? I/RxJavaTest: A
11-01 15:25:24.582 18453-18468/? I/RxJavaTest: 1
11-01 15:25:24.983 18453-18468/? I/RxJavaTest: 2
11-01 15:25:25.584 18453-18468/com.example.user.testproject I/RxJavaTest: 3
11-01 15:25:26.385 18453-18468/com.example.user.testproject I/RxJavaTest: 4
11-01 15:25:27.388 18453-18467/com.example.user.testproject I/RxJavaTest: G
11-01 15:25:27.388 18453-18467/com.example.user.testproject I/RxJavaTest: onCompleted

这样子就可以让Observable顺利发射完成。

第三种：

Observable<T> timeout(Func1<? super T, ? extends Observable<V>> timeoutSelector)
Observable<T>  timeout(Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> other)

这个谓词，他返回一个跟源Observable对应的Observable，当该谓词的Observable发射终止，源Observable还没有发射数据的时候，就发射一个TimeoutException给Observer的onError。第二个函数是不发射给onError，而是在源数据的基础之上继续发射替补的other。例如：

Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onNext("B");
                try {
                    Thread.currentThread().sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext("C");
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread()).timeout(new Func1<String, Observable<String>>() {
            @Override
            public Observable<String> call(String s) {
                return Observable.just(s).delay(50, TimeUnit.MILLISECONDS);
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i(TAG, "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.i(TAG, "onError" + e);
            }

            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        });

输出结果：

11-01 15:36:21.216 28118-28142/com.example.user.testproject I/RxJavaTest: A
11-01 15:36:21.217 28118-28142/com.example.user.testproject I/RxJavaTest: B
11-01 15:36:21.270 28118-28147/com.example.user.testproject I/RxJavaTest: onErrorjava.util.concurrent.TimeoutException

第二个函数也是类似的。


第四种：

Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> timeoutSelector)
Observable<T> timeout(Func0<? extends Observable<U>> firstTimeoutSelector, Func1<? super T, ? extends Observable<V>> timeoutSelector, Observable<? extends T> other)

这是可以给第一个Observable的数据设置超时，即当源Observable的第一个数据没有在firstTimeoutSelector的终止之前发射就会发射TimeoutException。其他的是跟上面类似，例子就不写了。
图：

Timestamp操作符

Observable<Timestamped<T>> timestamp()
Observable<Timestamped<T>> timestamp(Scheduler scheduler)

他的作用是把源数据包装一次，让它带有发射时间，包装之后的数据是Timestamped ，例如:

 Observable<String> ob = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("A");
                subscriber.onNext("B");
                try {
                    Thread.currentThread().sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext("C");
                subscriber.onCompleted();
            }
        });
        ob.subscribeOn(Schedulers.newThread()).timestamp().subscribe(new Action1<Timestamped<String>>() {
            @Override
            public void call(Timestamped<String> stringTimestamped) {
                Log.i(TAG, "timestamp" + stringTimestamped);
            }
        });

输出结果：

11-01 15:49:09.785 7365-7379/? I/RxJavaTest: timestampTimestamped(timestampMillis = 1478015349785, value = A)
11-01 15:49:09.785 7365-7379/? I/RxJavaTest: timestampTimestamped(timestampMillis = 1478015349785, value = B)
11-01 15:49:09.886 7365-7379/? I/RxJavaTest: timestampTimestamped(timestampMillis = 1478015349886, value = C)

图：

Using操作符

Observable<T> using(
            final Func0<Resource> resourceFactory,
            final Func1<? super Resource, ? extends Observable<? extends T>> observableFactory,
            final Action1<? super Resource> disposeAction)

Observable<T> using(
            final Func0<Resource> resourceFactory,
            final Func1<? super Resource, ? extends Observable<? extends T>> observableFactory,
            final Action1<? super Resource> disposeAction, boolean disposeEagerly)

创建一个只在Observable生命周期内存在的一次性资源，需要释放的资源，比如：

 Observable.using(new Func0<String>() {
            @Override
            public String call() {
                // 创建资源
                return "Hello";
            }
        }, new Func1<Object, Observable<?>>() {
            @Override
            public Observable<?> call(Object o) {
                //创建资源对应的Observable对象
                return Observable.just(o);
            }
        }, new Action1<Object>() {
            @Override
            public void call(Object o) {
                // 释放资源
            }
        }).subscribe(new Action1<Object>() {
            @Override
            public void call(Object o) {
                Log.i(TAG,o.toString());
            }
        });

其中第一个参数是创建资源，第二个参数是创建资源对应的Observable对象，第三个参数是释放资源。他适合与一些全局的一些需要被及时回收而我们需要确定他回收的资源。
图：