程序博客网 > 搞笑视频网站源码

RxJava操作符整理

来源：互联网 发布：搞笑视频网站源码 编辑：程序博客网 时间：2024/06/06 10:48

被观察者：Observable （可以想象成一个button） 创建包括：
1.Observable.just("Hello", "World") 
2. 2.String [] words = {"Hello", "World"};Observable observable3 = Observable.from(words);
3.List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
Observable observable4 = Observable.from(list);
观察者：Observer Subscriber Action0 Action1 Func1（可以想象成onclicklistener）
观察者各区别：
1.Observer 和Subscriber（都有onNext，onError onCompleted()）
Subscriber新增onStart()和unsubscribe()
onstart：可以用于做一些准备工作，例如数据的清零或重置
unsubscribe()：用于取消订阅
2.Action0 和Action1（比较简洁，只有一个call方法，都无返回）
Action0无参无返回 Action1有参无返回
3.Action和Func1的区别：
无返回和有返回。

 

 

操作符分类
按照官方的分类，操作符大致分为以下几种：

  • 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()等等；

 

1.创建型操作符

create操作符

create操作符是所有创建型操作符的“根”，也就是说其他创建型操作符最后都是通过create操作符来创建Observable的，其流程图例如下：

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    publicvoidcall(Subscriber<? super Integer> 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<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
});
运行结果如下： Next: 1 Next: 2 Next: 3 Next: 4 Sequence complete.

在使用create操作符时，最好要在回调的call函数中增加isUnsubscribed的判断，以便在subscriber在取消订阅时不会再执行call函数中相关代码逻辑，从而避免导致一些意想不到的错误出现；

from操作符

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

调用例子如下：
Integer[] items = { 0, 1, 2, 3, 4, 5 };
Observable myObservable = Observable.from(items);
 
myObservable.subscribe(
    new Action1<Integer>() {
        @Override
        publicvoidcall(Integer item) {
            System.out.println(item);
        }
    },
    new Action1<Throwable>() {
        @Override
        publicvoidcall(Throwable error) {
            System.out.println("Error encountered: " + error.getMessage());
        }
    },
    new Action0() {
        @Override
        publicvoidcall() {
            System.out.println("Sequence complete");
        }
    }
);
运行结果如下： 0 1 2 3 4 5 Sequence complete
调用例子如下：
Observable.just(1, 2, 3)
          .subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
    });
just操作符
just操作符也是把其他类型的对象和数据类型转化成Observable，它和from操作符很像，只是方法的参数有所差别
调用例子如下：
Observable.just(1, 2, 3)
          .subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
    });
 
defer操作符
defer操作符是直到有订阅者订阅时，才通过Observable的工厂方法创建Observable并执行，defer操作符能够保证Observable的状态是最新的
         i=10;
        Observable justObservable = Observable.just(i);
        i=12;
        Observable deferObservable = Observable.defer(new Func0<Observable<Object>>() {
            @Override
            public Observable<Object> call() {
                return Observable.just(i);
            }
        });
        i=15;
 
        justObservable.subscribe(new Subscriber() {
            @Override
            publicvoidonCompleted() {
 
            }
 
            @Override
            publicvoidonError(Throwable e) {
 
            }
 
            @Override
            publicvoidonNext(Object o) {
                System.out.println("just result:" + o.toString());
            }
        });
 
        deferObservable.subscribe(new Subscriber() {
            @Override
            publicvoidonCompleted() {
 
            }
 
            @Override
            publicvoidonError(Throwable e) {
 
            }
 
            @Override
            publicvoidonNext(Object o) {
                System.out.println("defer result:" + o.toString());
            }
        });
   }
Just输出10
Defer输出15
timer操作符
timer操作符是创建一串连续的数字，产生这些数字的时间间隔是一定的
一种是隔一段时间产生一个数字，然后就结束，可以理解为延迟产生数字
一种是每隔一段时间就产生一个数字，没有结束符，也就是是可以产生无限个连续的数字
        //每隔两秒产生一个数字
        Observable.timer(2, 2, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.out.println("error:" + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Long aLong) {
                System.out.println("Next:" + aLong.toString());
            }
        });
运行结果如下： 
Next:0 
Next:1 
Next:2 
Next:3
interval操作符
interval操作符是每隔一段时间就产生一个数字，这些数字从0开始，一次递增1直至无穷大；interval操作符的实现效果跟上面的timer操作符的第二种情形一样
调用例子同上
range操作符
range操作符是创建一组在从n开始，个数为m的连续数字，比如range(3,10)，就是创建3、4、5…12的一组数字，其流程实例如下
//产生从3开始，个数为10个的连续数字
        Observable.range(3,10).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.out.println("error:" + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer i) {
                System.out.println("Next:" + i.toString());
            }
        });
repeat/repeatWhen操作符
repeat操作符是对某一个Observable，重复产生多次结果
repeatWhen操作符是对某一个Observable，有条件地重新订阅从而产生多次结果，其流程实例如下
repeat调用例子如下：
//连续产生两组(3,4,5)的数字
        Observable.range(3,3).repeat(2).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.out.println("error:" + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer i) {
                System.out.println("Next:" + i.toString());
            }
        });
Next:3 Next:4 Next:5 Next:3 Next:4 Next:5 Sequence complete.
 
 
repeatWhen调用例子如下
Observable.just(1,2,3).repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {
            @Override
            public Observable<?> call(Observable<? extends Void> observable) {
                //重复3次
                return observable.zipWith(Observable.range(1, 3), new Func2<Void, Integer, Integer>() {
                    @Override
                    public Integer call(Void aVoid, Integer integer) {
                        return integer;
                    }
                }).flatMap(new Func1<Integer, Observable<?>>() {
                    @Override
                    public Observable<?> call(Integer integer) {
                        System.out.println("delay repeat the " + integer + " count");
                        //1秒钟重复一次
                        return Observable.timer(1, TimeUnit.SECONDS);
                    }
                });
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
运行结果如下： Next:1 Next:2 Next:3 repeat the 1 count Next:1 Next:2 Next:3 repeat the 2 count Next:1 Next:2 Next:3 repeat the 3 count Next:1 Next:2 Next:3 Sequence complete.
 
2.TransformingObservables(Observable的转换操作符)
 
Buffer操作符
buffer操作符周期性地收集源Observable产生的结果到列表中，并把这个列表提交给订阅者，订阅者处理后，清空buffer列表，同时接收下一次收集的结果并提交给订阅者，周而复始
调用例子如下：
//定义邮件内容
               
//每隔1秒就随机发布一封邮件
        Observable<String> endlessMail = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            publicvoidcall(Subscriber<? super String> subscriber) {
                try {
                    if (subscriber.isUnsubscribed()) return;
                    Random random = new Random();
                    while (true) {
                        String mail     mails[random.nextInt(mails.length)];                                                                                                                       
                        subscriber.onNext(mail);
                        Thread.sleep(1000);
                    }
                } catch (Exception ex) {
                    subscriber.onError(ex);
                }
            }
        }).subscribeOn(Schedulers.io());
        //把上面产生的邮件内容缓存到列表中，并每隔3秒通知订阅者
        endlessMail.buffer(3, TimeUnit.SECONDS).subscribe(new Action1<List<String>>() {
            @Override
            publicvoidcall(List<String> list) {
                System.out.println(String.format("You've got %d new messages!  Here they are!", list.size()));
                for (int i = 0; i < list.size(); i++)
                    System.out.println("**" + list.get(i).toString());
            }
        });
运行结果如下： 
You’ve got 3 new messages! Here they are!(after 3s) 
**Here is an email! 
**Another email! 
**Another email! 
You’ve got 3 new messages! Here they are!(after 6s) 
**Here is an email! 
**Another email! 
**Here is an email! 
map操作符
map操作符是把源Observable产生的结果，通过映射规则转换成另一个结果集，并提交给订阅者进行处理。
map操作符的流程图如下：
调用例子如下：
Observable.just(1,2,3,4,5,6).map(new Func1<Integer, Integer>() { 
            @Override
            public String call(Integerinteger) {
                //对源Observable产生的结果，都统一乘以3处理
                return Sting.valueof
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            publicvoid call(String integer) {
                System.out.println("next:"+integer);
            }
        });
 
运行结果如下： 
next:3 
next:6 
next:9 
next:12 
next:15 
next:18
 
flatMap操作符
flatMap操作符是把Observable产生的结果转换成多个Observable，然后把这多个Observable“扁平化”成一个Observable，并依次提交产生的结果给订阅者。
flatMap操作符通过传入一个函数作为参数转换源Observable，在这个函数中，你可以自定义转换规则，最后在这个函数中返回一个新的Observable，然后flatMap操作符通过合并这些Observable结果成一个Observable，并依次提交结果给订阅者。
值得注意的是，flatMap操作符在合并Observable结果时，有可能存在交叉的情况，。,
假设有一个id数组，通过每一个id数组去获取数据返回observable<Object>      
如果是map  返回值只能是一个Object
二者的区别
 
调用例子如下：
ApiManger.getState()
                .flatMap(newFunc1<StateModel, Observable<ChargeModel>>() {
                    @Override
                    publicObservable<ChargeModel> call(StateModel stateModel) {
                       returnstateModel.getState() != 1? Observable.empty() : apiManger.getCharge();
                    }
                })
                .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
                .subscribe(newSubscriber<ChargeNodel>() {
                    @Override
                    public void onCompleted() {
                        //hideLoading();
                    }
 
                    @Override
                    public voidonError(Throwable e) {
                        //hideLoading();
                    }
 
                    @Override
                    public voidonNext(ChargeModel chargeModel) {
                       
                         //充电
                        
                    }
                });
 
flatMap操作符
private Observable<File> listFiles(File f){
        if(f.isDirectory()){
            return Observable.from(f.listFiles).flatMap(new Func1<File, Observable<File>>() {
                @Override
                public Observable<File> call(File file) {
                    return listFiles(f);
                }
            });
        } else {
            return Observable.just(f);
        }
    }
 
 
    @Override
    publicvoidonClick(View v) {
        Observable.just(getApplicationContext().getExternalCacheDir())
                .flatMap(new Func1<File, Observable<File>>() {
                    @Override
                    public Observable<File> call(File file) {
                        //参数file是just操作符产生的结果，这里判断file是不是目录文件，如果是目录文件，则递归查找其子文件flatMap操作符神奇的地方在于，返回的结果还是一个Observable，而这个Observable其实是包含多个文件的Observable的，输出应该是ExternalCacheDir下的所有文件
                        return listFiles(file);
                    }
                })
                .subscribe(new Action1<File>() {
                    @Override
                    publicvoidcall(File file)                                                                
                                       System.out.println(file.getAbsolutePath());   
              }
                });
 
}
 
 
concatMap操作符 
ConcatMap操作符与flatMap操作符类似，都是把Observable产生的结果转换成多个Observable，然后把这多个Observable“扁平化”成一个Observable，并依次提交产生的结果给订阅者。
与flatMap操作符不同的是，concatMap操作符在处理产生的Observable时，采用的是“连接(concat)”的方式，而不是“合并(merge)”的方式，这就能保证产生结果的顺序性，也就是说提交给订阅者的结果是按照顺序提交的，不会存在交叉的情况。
concatMap的调用例子与flatMap类似，这里不做重复
 
switchMap操作符
switchMap操作符与flatMap操作符类似，都是把Observable产生的结果转换成多个Observable，然后把这多个Observable“扁平化”成一个Observable，并依次提交产生的结果给订阅者。
与flatMap操作符不同的是，switchMap操作符会保存最新的Observable产生的结果而舍弃旧的结果，举个例子来说，比如源Observable产生A、B、C三个结果，通过switchMap的自定义映射规则，映射后应该会产生A1、A2、B1、B2、C1、C2，但是在产生B2的同时，C1已经产生了，这样最后的结果就变成A1、A2、B1、C1、C2，B2被舍弃掉了！流程图如下：
以下是flatMap、concatMap和switchMap的运行实例对比：
 //flatMap操作符的运行结果
        Observable.just(10, 20, 30).flatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;
 
                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            publicvoidcall(Integer integer) {
                System.out.println("flatMap Next:" + integer);
            }
        });
 
        //concatMap操作符的运行结果
        Observable.just(10, 20, 30).concatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;
 
                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            publicvoidcall(Integer integer) {
                System.out.println("concatMap Next:" + integer);
            }
        });
 
        //switchMap操作符的运行结果
        Observable.just(10, 20, 30).switchMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;
 
                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            publicvoidcall(Integer integer) {
                System.out.println("switchMap Next:" + integer);
            }
        });
 
 
groupBy操作符
groupBy操作符是对源Observable产生的结果进行分组，形成一个类型为GroupedObservable的结果集，GroupedObservable中存在一个方法为getKey()，可以通过该方法获取结果集的Key值（类似于HashMap的key)。
值得注意的是，由于结果集中的GroupedObservable是把分组结果缓存起来，如果对每一个GroupedObservable不进行处理（既不订阅执行也不对其进行别的操作符运算），就有可能出现内存泄露。因此，如果你对某个GroupedObservable不进行处理，最好是对其使用操作符take(0)处理。
调用例子如下：
Observable.interval(1, TimeUnit.SECONDS).take(10).groupBy(new Func1<Long, Long>() {
            @Override
            public Long call(Long value) {
                //按照key为0,1,2分为3组
                returnvalue % 3;//%N  就是分成N份
            }
        }).subscribe(new Action1<GroupedObservable<Long, Long>>() {
            @Override
            publicvoidcall(GroupedObservable<Long, Long> result) {
                result.subscribe(new Action1<Long>() {
                    @Override
                    publicvoidcall(Long value) {
                        System.out.println("key:" + result.getKey() +", value:" + value);
                    }
                });
            }
        });
运行结果如下： 
Next:key 0 value0
Next:key 0 value1
Next:key 0 value2


cast操作符
cast操作符类似于map操作符，不同的地方在于map操作符可以通过自定义规则，把一个值A1变成另一个值A2，A1和A2的类型可以一样也可以不一样；而cast操作符主要是做类型转换的，传入参数为类型class，如果源Observable产生的结果不能转成指定的class，则会抛出ClassCastException运行时异常
Observable.just(1,2,3,4,5,6).cast(String.class).subscribe(new Action1<Integer>() {
            @Override
            publicvoidcall(Integer value) {
                System.out.println("next:"+value);
            }
        });
运行结果如下： 
next:1 
next:2 
next:3 
next:4 
next:5 
next:6
 
scan操作符
scan操作符通过遍历源Observable产生的结果，依次对每一个结果项按照指定规则进行运算，计算后的结果作为下一个迭代项参数，每一次迭代项都会把计算结果输出给订阅者。
Observable.just(“1”,“2”,“3”, “4”, “5”)
//第一次运行会略过
    .scan(new Func2<Integer, Integer, String>() {
        @Override
        public String call(Integer sum, Integer item) {
            //参数sum就是上一次的计算结果，第一次不执行运算
            return  sum + item;  
        }
    }).subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
    });
运行结果如下： 
Next: 1 
Next: 3 
Next: 6 
Next: 10 
Next: 15
如果将+换成*得出结果
Next: 1 
Next: 2 
Next: 6 
Next: 24 
Next: 120
Sequence complete. 
 
window操作符
window操作符非常类似于buffer操作符，区别在于buffer操作符产生的结果是一个List缓存，而window操作符产生的结果是一个Observable，订阅者可以对这个结果Observable重新进行订阅处理。
window操作符有很多个重载方法，这里只举一个简单的例子，其流程图如下：
 调用例子：
Observable.interval(1, TimeUnit.SECONDS).take(12)
                .window(3, TimeUnit.SECONDS)
                .subscribe(new Action1<Observable<Long>>() {
                    @Override
                    public void call(Observable<Long> observable) {
                       System.out.println("subdivide begin......");
                        observable.subscribe(new Action1<Long>() {//重新订阅          
                            @Override
                            public void call(Long aLong) {
                                System.out.println("Next:" + aLong);
                            }
                        });
                    }
                });
运行结果如下： 
subdivide begin…… 
Next:0 
Next:1 
subdivide begin…… 
Next:2 
Next:3 
Next:4 
subdivide begin…… 
Next:5 
Next:6 
Next:7 
subdivide begin…… 
Next:8 
Next:9 
Next:10 
subdivide begin…… 
Next:11
 
 
3.Filtering Observables(Observable的过滤操作符)
debounce操作符
调用例子如下：
Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            publicvoidcall(Subscriber<? super Integer> subscriber) {
                if(subscriber.isUnsubscribed()) return;
                try {
                    //产生结果的间隔时间分别为100、200、300...900毫秒
                    for (int i = 1; i < 10; i++) {
                        subscriber.onNext(i);
                        Thread.sleep(i * 100);
                    }
                    subscriber.onCompleted();
                }catch(Exception e){
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
       //采集在一定时间内产生的数据
          .debounce(400, TimeUnit.MILLISECONDS)  //超时时间为400毫秒
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    publicvoidcall(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    publicvoidcall(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    publicvoidcall() {
                        System.out.println("completed!");
                    }
                });
运行结果如下： Next:4 Next:5 Next:6 Next:7 Next:8 Next:9 completed!
 
distinct操作符
distinct操作符对源Observable产生的结果进行过滤，把重复的结果过滤掉，只输出不重复的结果给订阅者，非常类似于SQL里的distinct关键字
调用例子如下：
Observable.just(1, 2, 1, 1, 2, 3)
          .distinct()
          .subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
});
运行结果如下： Next: 1 Next: 2 Next: 3 Sequence complete.
elementAt操作符
elementAt操作符在源Observable产生的结果中，仅仅把指定索引的结果提交给订阅者，索引是从0开始的。
调用例子如下：
Observable.just(1,2,3,4,5,6).elementAt(2)
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    publicvoidcall(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    publicvoidcall(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    publicvoidcall() {
                        System.out.println("completed!");
                    }
                });
运行结果如下： 
Next:3 
completed!
 
filter操作符
filter操作符是对源Observable产生的结果按照指定条件进行过滤，只有满足条件的结果才会提交给订阅者
调用例子如下：
Observable.just(1, 2, 3, 4, 5)
          .filter(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer item) {
                return( item < 4 );
              }
          }).subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
    });
运行结果如下： 
Next: 1 
Next: 2 
Next: 3 
Sequence complete.
ofType操作符
ofType操作符类似于filter操作符，区别在于ofType操作符是按照类型对结果进行过滤，
调用例子如下：
Observable.just(1, "hello world", true, 200L, 0.23f)
          .ofType(Float.class)
          .subscribe(new Subscriber<Object>() {
              @Override
              publicvoidonNext(Object item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： 
Next: 0.23 
Sequence complete.
 
first操作符
first操作符是把源Observable产生的结果的第一个提交给订阅者，first操作符可以使用elementAt(0)和take(1)替代。
调用例子如下：
Observable.just(1,2,3,4,5,6,7,8)
          .first()
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： 
Next: 1 
Sequence complete.
 
single操作符
single操作符是对源Observable的结果进行判断，如果产生的结果满足指定条件的数量不为1，则抛出异常，否则把满足条件的结果提交给订阅者，
调用例子如下：
Observable.just(1,2,3,4,5,6,7,8,11)
          .single(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer integer) {
                  //取大于10的第一个数字
                  return integer>10;
              }
          })
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： 
Error: Sequence contains no elements
 
last操作符
last操作符把源Observable产生的结果的最后一个提交给订阅者，last操作符可以使用takeLast(1)替代。
调用例子如下：
Observable.just(1, 2, 3)
          .last()
          .subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
    });
运行结果如下： 
Next: 3 
Sequence complete.
 
ignoreElements操作符
ignoreElements操作符忽略所有源Observable产生的结果，只把Observable的onCompleted和onError事件通知给订阅者。ignoreElements操作符适用于不太关心Observable产生的结果，只是在Observable结束时(onCompleted)或者出现错误时能够收到通知。
调用例子如下：
Observable.just(1,2,3,4,5,6,7,8).ignoreElements()
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： 
Sequence complete.
 
sample操作符
sample操作符定期扫描源Observable产生的结果，在指定的时间间隔范围内对源Observable产生的结果进行采样。
调用例子如下：
Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            publicvoidcall(Subscriber<? super Integer> subscriber) {
                if(subscriber.isUnsubscribed()) 
                        return;                              
                try {
                    //前8个数字产生的时间间隔为1秒，后一个间隔为3秒
                    for (int i = 1; i < 9; i++) {
                        subscriber.onNext(i);
                        Thread.sleep(1000);
                    }
                    Thread.sleep(2000);
                    subscriber.onNext(9);
                    subscriber.onCompleted();
                } catch(Exception e){
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
          .sample(2200, TimeUnit.MILLISECONDS)  //采样间隔时间为2200毫秒
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： 
Next: 3 
Next: 5 
Next: 7 
Next: 8 
Sequence complete.
 
skip操作符
skip操作符针对源Observable产生的结果，跳过前面n个不进行处理，而把后面的结果提交给订阅者处理，
调用例子如下：
Observable.just(1,2,3,4,5,6,7).skip(3)
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： 
Next: 4 
Next: 5 
Next: 6 
Next: 7 
Sequence complete.
 
skipLast操作符
skipLast操作符针对源Observable产生的结果，忽略Observable最后产生的n个结果，而把前面产生的结果提交给订阅者处理，
可以看到skipLast操作符把最后的天蓝色球、蓝色球、紫色球忽略掉了，但是前面的红色球等并不是源Observable一产生就直接提交给订阅者，这里有一个延迟的效果
 
调用例子如下：
 
Observable.just(1,2,3,4,5,6,7).skipLast(3)
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： Next: 1 Next: 2 Next: 3 Next: 4 Sequence complete.
take操作符
take操作符是把源Observable产生的结果，提取前面的n个提交给订阅者，而忽略后面的结果
调用例子如下：
Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
          .take(4)
          .subscribe(new Subscriber<Integer>() {
        @Override
        publicvoidonNext(Integer item) {
            System.out.println("Next: " + item);
        }
 
        @Override
        publicvoidonError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }
 
        @Override
        publicvoidonCompleted() {
            System.out.println("Sequence complete.");
        }
    });
运行结果如下： Next: 1 Next: 2 Next: 3 Next: 4 Sequence complete.
 
takeFirst操作符
takeFirst操作符类似于take操作符，同时也类似于first操作符，都是获取源Observable产生的结果列表中符合指定条件的前一个或多个，与first操作符不同的是，first操作符如果获取不到数据，则会抛出NoSuchElementException异常，而takeFirst则会返回一个空的Observable，该Observable只有onCompleted通知而没有onNext通知。
调用例子如下：
 
Observable.just(1,2,3,4,5,6,7).takeFirst(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                //获取数值大于3的数据
                return integer>3;
            }
        })
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： Next: 4 Sequence complete.
 
takeLast操作符
takeLast操作符是把源Observable产生的结果的后n项提交给订阅者，提交时机是Observable发布onCompleted通知之时。
调用例子如下：
 
Observable.just(1,2,3,4,5,6,7).takeLast(2)
          .subscribe(new Subscriber<Integer>() {
              @Override
              publicvoidonNext(Integer item) {
                  System.out.println("Next: " + item);
              }
 
              @Override
              publicvoidonError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }
 
              @Override
              publicvoidonCompleted() {
                  System.out.println("Sequence complete.");
              }
          });
运行结果如下： Next: 6 Next: 7 Sequence complete.
 
 
4.CombiningObservables(Observable的组合操作符)
combineLatest操作符
 
combineLatest操作符把两个Observable产生的结果进行合并，合并的结果组成一个新的Observable。这两个Observable中任意一个Observable产生的结果，都和另一个Observable最后产生的结果，按照一定规则拼接
 
 
调用例子如下:
//产生0,5,10,15,20数列
        Observable<Long> observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 5;
                    }
                }).take(5);
 
        //产生0,10,20,30,40数列
        Observable<Long> observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 10;
                    }
                }).take(5);
 
 
        Observable.combineLatest(observable1, observable2, new Func2<Long, Long, Long>() {
            @Override
            public Long call(Long aLong, Long aLong2) {
                return aLong+aLong2;
            }
        }).subscribe(new Subscriber<Long>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Long aLong) {
                System.out.println("Next: " + aLong);
            }
        });
运行结果如下：(observable1的1、2和observable2的1，observable1的2、3和observable2的2以此类推)
Next: 0 
Next: 5 
Next: 15 
Next: 20 
Next: 30 
Next: 35 
Next: 45 
Next: 50 
Next: 60 
Sequence complete.
 
join操作符
join操作符把类似于combineLatest操作符，也是两个Observable产生的结果进行合并，合并的结果组成一个新的Observable，但是join操作符可以控制每个Observable产生结果的生命周期，在每个结果的生命周期内，可以与另一个Observable产生的结果按照一定的规则进行合并(与combineLatest相比只是通过observable多处理了一层，所以说可以控制生命周期（delay操作符）)
第四个参数的Func的参数是以Long的形式
join方法的用法如下： 
observableA.join(observableB, 
observableA产生结果生命周期控制函数， 
observableB产生结果生命周期控制函数， 
observableA产生的结果与observableB产生的结果的合并规则）
 
调用例子如下：
//产生0,5,10,15,20数列
        Observable<Long> observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 5;
                    }
                }).take(5);
 
        //产生0,10,20,30,40数列
        Observable<Long> observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 10;
                    }
                }).take(5);
 
        observable1.join(observable2, new Func1<Long, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong) {
                //使Observable延迟600毫秒执行
          return Observable.just(aLong).delay(600,                                                              TimeUnit.MILLISECONDS);                                                    
            }
        }, new Func1<Long, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong) {
                //使Observable延迟600毫秒执行
                return Observable.just(aLong).delay(600, TimeUnit.MILLISECONDS);
            }
        }, new Func2<Long, Long, Long>() {
            @Override
            public Long call(Long aLong, Long aLong2) {
                return aLong + aLong2;
            }
        }).subscribe(new Subscriber<Long>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Long aLong) {
                System.out.println("Next: " + aLong);
            }
        });
运行结果如下： Next: 0 Next: 5 Next: 15 Next: 20 Next: 30 Next: 35 Next: 45 Next: 50 Next: 60 Sequence complete.
 
groupJoin操作符
groupJoin操作符非常类似于join操作符，区别在于join操作符中第四个参数的传入函数不一致（第四个参数的Func的参数是以Observable的形式）
调用例子如下：
 
//产生0,5,10,15,20数列
        Observable<Long> observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 5;
                    }
                }).take(5);
 
        //产生0,10,20,30,40数列
        Observable<Long> observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 10;
                    }
                }).take(5);
 
        observable1.groupJoin(observable2, new Func1<Long, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong) {
                return Observable.just(aLong).delay(1600, TimeUnit.MILLISECONDS);
            }
        }, new Func1<Long, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong) {
                return Observable.just(aLong).delay(600, TimeUnit.MILLISECONDS);
            }
        }, new Func2<Long, Observable<Long>, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong, Observable<Long> observable) {
                return observable.map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong2) {
                        return aLong + aLong2;
                    }
                });
            }
        }).subscribe(new Subscriber<Observable<Long>>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Observable<Long> observable) {
                observable.subscribe(new Subscriber<Long>() {
                    @Override
                    publicvoidonCompleted() {
 
                    }
 
                    @Override
                    publicvoidonError(Throwable e) {
 
                    }
 
                    @Override
                    publicvoidonNext(Long aLong) {
                        System.out.println("Next: " + aLong);
                    }
                });
            }
        });
运行结果如下： 
Next: 0 
Next: 5 
Next: 10 
Next: 15 
Next: 20 
Next: 25 
Next: 30 
Next: 35 
Next: 40 
Next: 45 
Next: 50 
Next: 60 
Next: 55 
Sequence complete.
 
merge操作符（发生错误时中断。）
merge操作符是按照两个Observable提交结果的时间顺序，对Observable进行合并，如ObservableA每隔500毫秒产生数据为0,5,10,15,20；而ObservableB每隔500毫秒产生数据0,10,20,30,40，其中第一个数据延迟500毫秒产生，最后合并结果为：0,0,5,10,10,20,15,30,20,40;其流程图如下
 
调用例子如下：
//产生0,5,10,15,20数列
        Observable<Long> observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 5;
                    }
                }).take(5);
 
        //产生0,10,20,30,40数列
        Observable<Long> observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 10;
                    }
                }).take(5);
 
        Observable.merge(observable1, observable2)
                .subscribe(new Subscriber<Long>() {
                    @Override
                    publicvoidonCompleted() {
                        System.out.println("Sequence complete.");
                    }
 
                    @Override
                    publicvoidonError(Throwable e) {
                        System.err.println("Error: " + e.getMessage());
                    }
 
                    @Override
                    publicvoidonNext(Long aLong) {
                        System.out.println("Next:" + aLong);
                    }
                });
运行结果如下： 
Next:0 
Next:0 
Next:5 
Next:10 
Next:10 
Next:20 
Next:15 
Next:30 
Next:20 
Next:40 
Sequence complete.
 
mergeDelayError操作符（发生错误时不中断，最后才执行）
从merge操作符的流程图可以看出，一旦合并的某一个Observable中出现错误，就会马上停止合并，并对订阅者回调执行onError方法，而mergeDelayError操作符会把错误放到所有结果都合并完成之后才执行，其流程图如下：
调用例子如下：
//产生0,5,10数列,最后会产生一个错误
        Observable<Long> errorObservable = Observable.error(new Exception("this is end!"));
        Observable < Long > observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 5;
                    }
                }).take(3).mergeWith(errorObservable.delay(3500, TimeUnit.MILLISECONDS));
 
        //产生0,10,20,30,40数列
        Observable<Long> observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 10;
                    }
                }).take(5);
 
        Observable.mergeDelayError(observable1, observable2)
                .subscribe(new Subscriber<Long>() {
                    @Override
                    publicvoidonCompleted() {
                        System.out.println("Sequence complete.");
                    }
 
                    @Override
                    publicvoidonError(Throwable e) {
                        System.err.println("Error: " + e.getMessage());
                    }
 
                    @Override
                    publicvoidonNext(Long aLong) {
                        System.out.println("Next:" + aLong);
                    }
                });
运行结果如下： 
Next:0 
Next:0 
Next:5 
Next:10 
Next:10 
Next:20 
Next:30 
Next:40 
Error: this is end!
 
startWith操作符（将插入的值放前面）
startWith操作符是在源Observable提交结果之前，插入指定的某些数据
调用例子如下：
Observable.just(10,20,30).startWith(2, 3, 4).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
运行结果如下： 
Next:2 
Next:3 
Next:4 
Next:10 
Next:20 
Next:30 
Sequence complete.
 
switchOnNext操作符
switchOnNext操作符是把一组Observable转换成一个Observable，转换规则为：对于这组Observable中的每一个Observable所产生的结果，如果在同一个时间内存在两个或多个Observable提交的结果，只取最后一个Observable提交的结果给订阅者，
调用例子如下：
//每隔500毫秒产生一个observable
        Observable<Observable<Long>> observable = Observable.timer(0, 500, TimeUnit.MILLISECONDS).map(new Func1<Long, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong) {
                //每隔200毫秒产生一组数据（0,10,20,30,40)
                return Observable.timer(0, 200, TimeUnit.MILLISECONDS).map(new Func1<Long, Long>() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 10;
                    }
                }).take(5);
            }
        }).take(2);
 
        Observable.switchOnNext(observable).subscribe(new Subscriber<Long>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Long aLong) {
                System.out.println("Next:" + aLong);
            }
        });
 
运行结果如下：
Next:0
Next:10
Next:20
Next:0
Next:10
Next:20
Next:30
Next:40
Sequence complete.
Zip操作符
zip操作符是把两个observable提交的结果，严格按照顺序进行合并
调用例子如下：
Observable<Integer> observable1 = Observable.just(10,20,30);
 Observable<Integer> observable2 = Observable.just(4, 8, 12, 16);
        Observable.zip(observable1, observable2, new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                return integer + integer2;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
运行结果如下： 
Next:14 
Next:28 
Next:42 
Sequence complete.
 
 
zipWith操作符
ApiManger apiManger= RetrofitHelper.getManger();
apiManger.getMoney()
        .zipWith(apiManger.getCharge(), new Func2<MoneyModel, ChargeModel, int >() {
            @Override
            public int call(MoneyModel moneyModel,ChargeModel chargeModel) {
                return moneyModel.getMoney()+ chargeModel.getPrice();
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber<Boolean>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Boolean aBoolean){
                //购买
               If{!aBoolean}{
                       //余额不足
                 }else{
                       //购买
                 }
            }
        });
 
 
 
 
 
5.Error HandlingOperators(Observable的错误处理操作符)
onErrorReturn操作符
onErrorReturn操作符是在Observable发生错误或异常的时候（即将回调oError方法时），拦截错误并执行指定的逻辑，返回一个跟源Observable相同类型的结果，最后回调订阅者的onComplete方法
调用例子如下：
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            publicvoidcall(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            thrownew Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });
 
        observable.onErrorReturn(new Func1<Throwable, Integer>() {
            @Override
            public Integer call(Throwable throwable) {
                return1004;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
运行结果如下： 
Next:0 
Next:1 
Next:2 
Next:3 
Next:1004 
Sequence complete.
onErrorResumeNext操作符
onErrorResumeNext操作符跟onErrorReturn类似，只不过onErrorReturn只能在错误或异常发生时只返回一个和源Observable相同类型的结果，而onErrorResumeNext操作符是在错误或异常发生时返回一个Observable，也就是说可以返回多个和源Observable相同类型的结果，
调用例子如下：
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            publicvoidcall(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            thrownew Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });
 
        observable.onErrorResumeNext(new Func1<Throwable, Observable<? extends Integer>>() {
            @Override
            public Observable<? extends Integer> call(Throwable throwable) {
                return Observable.just(100,101, 102);
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
运行结果如下： 
Next:0 
Next:1 
Next:2 
Next:3 
Next:100 
Next:101 
Next:102 
Sequence complete.
onExceptionResumeNext操作符
onExceptionResumeNext操作符和onErrorResumeNext操作符类似，不同的地方在于onErrorResumeNext操作符是当Observable发生错误或异常时触发，而onExceptionResumeNext是当Observable发生异常时才触发。
调用例子如下：
Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            publicvoidcall(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            thrownew Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Throwable e) {
                    subscriber.onError(e);
                }
            }
        });
  observable.onExceptionResumeNext(Observable.just(100, 101, 102)).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
运行结果如下： 
Next:0 
Next:1 
Next:2 
Next:3 
Next:100 
Next:101 
Next:102 
Sequence complete.
retry操作符
retry操作符是当Observable发生错误或者异常时，重新尝试执行Observable的逻辑，如果经过n次重新尝试执行后仍然出现错误或者异常，则最后回调执行onError方法；当然如果源Observable没有错误或者异常出现，则按照正常流程执行。其流程图如下：
调用例子如下：Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            publicvoidcall(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            thrownew Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Throwable e) {
                    subscriber.onError(e);
                }
            }
        });
 
        observable.retry(2).subscribe(new Subscriber<Integer>() {
            @Override
            publicvoidonCompleted() {
                System.out.println("Sequence complete.");
            }
 
            @Override
            publicvoidonError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }
 
            @Override
            publicvoidonNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });
 
 
 
运行结果如下 
Next:0 
Next:1 
Next:2 
Next:3
Next:0 
Next:1 
Next:2 
Next:3
Next:0 
Next:1 
Next:2 
Next:3 
Error: this is number 4 error！
retry和repeatwhen的区别
一个是调用oncomplete后执行再次执行
一个是调用onError后再次执行
 
 
一些参考资料：
1.RxJava api查询  
http://reactivex.io/RxJava/1.x/javadoc/
2.RxJava实际运用运用的小场景
http://www.jianshu.com/p/91ec3676ddbb
3.RxJava操作符运用的demo
https://github.com/rengwuxian/RxJavaSamples

                                             
        0        0           
	
				
		









 搞笑视频网站源码
    		搞笑视频网站源码



原创粉丝点击



		

热门IT博客


照片编辑手机软件知乎照片编辑手机软件知乎




445端口怎么打开445端口怎么打开




linux下 ansi转utf8




linux 服务网络吞吐




java web整合开发实战




华为 高通 知乎




杭州java招聘




sha256算法实现原理




查看linux安装的字体




数据挖掘视频




rpg手游 知乎




安卓平台c语言编译器




淘宝客佣金怎么看




软件开发预付款比例




多说 embed.js




h端口双向储能控制器




eclipse导入安卓源码




手机特效软件有哪些




淘宝怎么辨别死人衣服




php 获取远程网页内容



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    时代香海彼岸
    香海彼岸
    中山时代香海北岸
    威海那香海旅游度假区
    永川香海温泉酒店
    香海大桥规划图超清
    珠海时代香海彼岸
    兴龙香玺海
    海因策
    海因茨
    十二国记主题曲
    十二国记结局各国结局
    十二国记之
    海图片
    猴子观海图片
    海白菜图片
    哪吒闹海图片
    海葡萄图片
    海的女儿图片
    海笋图片
    流海大全图片
    薰衣草图片花海
    海宝电动三轮车图片及价格表
    黄山猴子观海图片
    海鲫鱼图片
    海堂花图片
    海蜈蚣图片
    海蚌图片
    海蟑螂图片
    海花岛图片
    海来阿木女儿图片
    海帕杰顿图片
    海陵岛图片
    海蚯蚓图片
    海茄子图片
    海百合图片
    庐山西海图片
    油菜花海图片
    海泥鳅图片
    跳海图片
    流海图片


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里