RxJava2.0----事件流操作符Observable Utility Operators

6.事件流操作符Observable Utility Operators

A toolbox of useful Operators for working with Observables
● Delay
● Do
● Materialize/Dematerialize
● Serialize
● TimeInterval
● Timeout
● Timestamp
● Using
● To
● Retry
● cache
● cast
● compese

● Delay
将一个事件流里的数据源全部都延时发送。

● Do
在观察者订阅前，接收数据前后，完成接收前后，事件流过程中发生错误后，事件流结束前后等回调被观察者通知
doAfterTerminate doOnComplete doOnDispose doOnEach doOnError doOnLifecycle doOnNext doOnSubscribe doOnTerminate onTerminateDetach

  private Observer observer = new Observer() {
        @Override
        public void onSubscribe(Disposable d) {
            print("onSubscribe ");
        }

        @Override
        public void onNext(Integer integer) {
            print("onNext "+integer);
        }

        @Override
        public void onError(Throwable e) {
            print("onError "+e.getMessage());
        }

        @Override
        public void onComplete() {
            print("onComplete " );
        }
    };
    private Observable getObservable(final boolean isError){
        return  Observable.just(1,2,3,4,5)
                .doOnSubscribe(new Consumer() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        print("doOnSubscribe ");
                    }
                })
                .doOnEach(new Consumer>() {
                    @Override
                    public void accept(Notification integerNotification) throws Exception {
                        print("doOnEach :"+integerNotification);
                    }
                }).doAfterNext(new Consumer() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        print("doAfterNext : "+integer  );
                        if(isError && integer == 3){
                            throw new Exception("There is a Error!!");
                        }
                    }
                }).doAfterTerminate(new Action() {
                    @Override
                    public void run() throws Exception {
                        print("doAfterTerminate : "  );
                    }
                }).doOnComplete(new Action() {
                    @Override
                    public void run() throws Exception {
                        print("doOnComplete : "  );
                    }
                }).doFinally(new Action() {
                    @Override
                    public void run() throws Exception {
                        print("doFinally : "  );
                    }
                }).doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        print("doOnDispose : "  );
                    }
                }).doOnTerminate(new Action() {
                    @Override
                    public void run() throws Exception {
                        print("doOnTerminate : "  );
                    }
                }).onTerminateDetach()
                .doOnError(new Consumer() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        print("doOnError : "  );
                    }
                }).doOnLifecycle(new Consumer() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        print("doOnLifecycle : accept"  );
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        print("doOnLifecycle Action : "  );
                    }
                });
    }
    private void doAct1() {
        //需要引入RxJava 1.0
        //-------------buffer operator------
        tx_console.setText("Do");
        getObservable(false).subscribe(observer);
Log.d(" ", "  =================");
        getObservable(true).subscribe(observer);
}
输出结果：
  doOnSubscribe
          doOnLifecycle : accept
          onSubscribe
          doOnEach :OnNextNotification[1]
          onNext 1
          doAfterNext : 1
          doOnEach :OnNextNotification[2]
          onNext 2
          doAfterNext : 2
          doOnEach :OnNextNotification[3]
          onNext 3
          doAfterNext : 3
          doOnEach :OnNextNotification[4]
          onNext 4
          doAfterNext : 4
          doOnEach :OnNextNotification[5]
          onNext 5
          doAfterNext : 5
          doOnEach :OnCompleteNotification
          doOnComplete :
          doOnTerminate :
          onComplete
          doFinally :
          doAfterTerminate :
================================

          doOnSubscribe
          doOnLifecycle : accept
          onSubscribe
          doOnEach :OnNextNotification[1]
          onNext 1
          doAfterNext : 1
          doOnEach :OnNextNotification[2]
          onNext 2
          doAfterNext : 2
          doOnEach :OnNextNotification[3]
          onNext 3
          doAfterNext : 3
          doOnTerminate :
          doOnError :
          onError There is a Error!!
          doFinally :
          doAfterTerminate :

● Materialize/Dematerialize
Materialize返回一个被观察者对象，该对象发射源数据的所有数据，以及通知，每一项item通过一个标记类Notification封装源数据以及通知。Dematerialize 则和materialize功能相反。

 Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext("aaaa");
                e.onNext("bbbb");
                e.onNext("cccc");
                e.onComplete();
            }
        }).materialize()
                .map(new Function, Notification>() {
            @Override
            public Notification apply(Notification stringNotification) throws Exception {
                print("materialize:"+stringNotification +"--->getValue:"+stringNotification.getValue()
                        +"--->isOnComplete:"+stringNotification.isOnComplete()
                        +"--->isOnError:"+stringNotification.isOnError() );
                return stringNotification;
            }
        }).dematerialize().subscribe(new Consumer