Rxjava2 Observable的辅助操作详解及实例（二）

接续上篇： Rxjava2 Observable的辅助操作详解及实例（一）

8. TimeInterval

将一个发射数据的Observable转换为发射那些数据发射时间间隔的Observable。

TimeInterval 操作符拦截原始Observable发射的数据项，替换为发射表示相邻发射物时间间隔的对象。

这个操作符将原始 Observable 转换为另一个 Observable ，后者发射一个标志替换前者的数据项，这个标志表示前者的两个连续发射物之间流逝的时间长度。新的Observable的第一个发射物表示的是在观察者订阅原始 Observable 到原始 Observable 发射它的第一项数据之间流逝的时间长度。不存在与原始 Observable 发射最后一项数据和发射 onCompleted 通知之间时长对应的发射物。

示例代码：

    /**
     * 1. timeInterval(Scheduler scheduler)
     *  scheduler: 可选参数，指定调度线程
     *  接收原始数据项，发射射表示相邻发射物时间间隔的对象
     */
    Observable.intervalRange(1, 10, 100, 100, TimeUnit.MILLISECONDS)
            .timeInterval()
         // .timeInterval(Schedulers.newThread())       // 指定工作线程
            .subscribe(new Observer<Timed<Long>>() {
   
                @Override
                public void onSubscribe(Disposable d) {
   
                    System.out.println("--> onSubscribe(1)");
                }

                @Override
                public void onNext(Timed<Long> longTimed) {
   
                    long time = longTimed.time();           // 连续数据间的间隔时间
                    TimeUnit unit = longTimed.unit();       // 连续数据间的时间间隔单位
                    Long value = longTimed.value();         // Observable发送的数据项
                    System.out.println("--> onNext(1): " + longTimed.toString());
                }

                @Override
                public void onError(Throwable e) {
   
                    System.out.println("--> onError(1): " + e);
                }

                @Override
                public void onComplete() {
   
                    System.out.println("--> onComplete(1)");
                }
            });

    System.in.read();
    System.out.println("-------------------------------------------------");
    /**
     *  2. timeInterval(TimeUnit unit, Scheduler scheduler)
     *  指定时间间隔单位和指定工作线程，接收原始数据项，发射射表示相邻发射物时间间隔的对象
     */
    Observable.intervalRange(1, 10, 1000, 1200, TimeUnit.MILLISECONDS)
        //  .timeInterval(TimeUnit.SECONDS)                             // 指定时间间隔单位
            .timeInterval(TimeUnit.SECONDS, Schedulers.newThread())     // 指定时间间隔单位和指定工作线程
            .subscribe(new Observer<Timed<Long>>() {
   
                @Override
                public void onSubscribe(Disposable d) {
   
                    System.out.println("--> onSubscribe(2)");
                }

                @Override
                public void onNext(Timed<Long> longTimed) {
   
                    System.out.println("--> onNext(2): " + longTimed.toString());
                }

                @Override
                public void onError(Throwable e) {
   
                    System.out.println("--> onError(2): " + e);
                }

                @Override
                public void onComplete() {
   
                    System.out.println("--> onComplete(2)");
                }
            });

    System.in.read();

输出：

--> onSubscribe(1)
--> onNext(1): Timed[time=104, unit=MILLISECONDS, value=1]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=2]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=3]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=4]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=5]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=6]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=7]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=8]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=9]
--> onNext(1): Timed[time=100, unit=MILLISECONDS, value=10]
--> onComplete(1)
-------------------------------------------------
--> onSubscribe(2)
--> onNext(2): Timed[time=1, unit=SECONDS, value=1]
--> onNext(2): Timed[time=1, unit=SECONDS, value=2]
--> onNext(2): Timed[time=1, unit=SECONDS, value=3]
--> onNext(2): Timed[time=1, unit=SECONDS, value=4]
--> onNext(2): Timed[time=1, unit=SECONDS, value=5]
--> onNext(2): Timed[time=2, unit=SECONDS, value=6]
--> onNext(2): Timed[time=1, unit=SECONDS, value=7]
--> onNext(2): Timed[time=1, unit=SECONDS, value=8]
--> onNext(2): Timed[time=1, unit=SECONDS, value=9]
--> onNext(2): Timed[time=1, unit=SECONDS, value=10]
--> onComplete(2)

Javadoc: timeInterval()
Javadoc: timeInterval(Scheduler scheduler)
Javadoc: timeInterval(TimeUnit unit)
Javadoc: timeInterval(TimeUnit unit, Scheduler scheduler)

9. Timeout

对原始Observable的一个镜像，如果过了一个指定的时长仍没有发射数据，它会发一个错误通知。

RxJava中的实现为 timeout 操作符，具有多个不同的变体。

9.1 timeout(timeout, timeUnit)

如果原始 Observable 过了指定的一段时长没有发射任何数据，Timeout操作符会以一个 onError 通知终止这个Observable。

示例代码：

    /**
     *  1. timeout(long timeout, TimeUnit timeUnit)
     *  接受一个时长参数，如果在指定的时间段内没有数据项发射，将会发射一个Error通知，
     *  或者每当原始Observable发射了一项数据， timeout 就启动一个计时器，
     *  如果计时器超过了指定指定的时长而原始Observable没有发射另一项数据， 
     *  就抛出 TimeoutException ，以一个错误通知终止Observable。
     */
    Observable.create(new ObservableOnSubscribe<Long>() {
   
        @Override
        public void subscribe(ObservableEmitter<Long> emitter) throws Exception {
   
            //  Thread.sleep(2000);     // 延迟2秒后发射数据，此时会有TimeoutException
            emitter.onNext(1L);
            Thread.sleep(2000);     // 延迟2秒后发射数据，此时会有TimeoutException
            emitter.onNext(2L);
            emitter.onComplete();
        }
    }).timeout(1, TimeUnit.SECONDS)     // 指定超时时间段为1秒
      .subscribe(new Observer<Long>() {
   
            @Override
            public void onSubscribe(Disposable d) {
   
                System.out