RxJava操作符简记

最新推荐文章于 2023-03-23 09:00:26 发布

azhoufeng

最新推荐文章于 2023-03-23 09:00:26 发布

阅读量436

点赞数 2

分类专栏： RxIava Android

本文链接：https://blog.csdn.net/androidzf/article/details/84303588

版权

Android 同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

RxIava

3 篇文章 0 订阅

订阅专栏

官方文档

RxAndroid源码

ProgressOn思维导图

一、创建操作符

1、create操作符

创建一个被观察者Observable对象

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
    }
});

2、just操作符

快速创建一个被观察者Observable对象
创建完成之后直接将just()方法的参数发送给观察者
just()有十个重载方法，最少一个参数，最多十个参数。

  Observable
    .just(1, 2, 3, 4)
    .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
        }

        @Override
        public void onNext(Integer integer) {
            Log.e("=========", "===onNext==>" + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e("=========", "===onComplete==>");
        }
    });

打印结果为：

 ===onNext==>1
 ===onNext==>2
 ===onNext==>3
 ===onNext==>4
 ===onComplete==>

3、fromArray操作符

快速创建一个Observable对象
直接发送传入的变长数组，遍历数组

  Observable
    .fromArray(1,2,3,4)
    .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(Integer integer) {
            Log.e("=========", "===onNext==>" + integer);
        }
        @Override
        public void onError(Throwable e) {
            Log.e("=========", "===onError==>" +e.getMessage());
        }
        @Override
        public void onComplete() {
            Log.e("=========", "===onComplete==>");
        }
    });

打印结果：

 ===onNext==>1
 ===onNext==>2
 ===onNext==>3
 ===onNext==>4
 ===onComplete==>

4、fromIterable操作符

快速创建一个Observable对象
直接发送传入的集合，遍历集合

List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
Observable
    .fromIterable(list)
    .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(Integer integer) {
            Log.e("=========", "===onNext==>" + integer);
        }
        @Override
        public void onError(Throwable e) {
            Log.e("=========", "===onError==>" +e.getMessage());
        }
        @Override
        public void onComplete() {
            Log.e("=========", "===onComplete==>");
        }
    });

打印结果：

 ===onNext==>1
 ===onNext==>2
 ===onNext==>3
 ===onNext==>4
 ===onComplete==>

二、变换操作符

1、map操作符

map操作符的作用是将被观察者Observable发送的数据在apply()方法中转化成自己需要的返回到下游Observer的onNext()方法中。例：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onComplete();
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer s) throws Exception {
                if (s > 2) {
                    return "aaa";
                }
                return "bbb";
            }
        }).subscribe(new Observer<String>() {
            ...
            @Override
            public void onNext(String s) {
                Log.e("==============", "===onNext==>" + s);
            }
            ...
        });

map操作符将Observable发送的Integer类型参数1、2、3、4通过条件判断转化成"aaa"、”bbb"返回到Observer的onNext()方法中。

2、flatMap操作符

将Observable发射的数据在apply()方法中接收后转化为新的Observable发射出去，每接收一个数据发送一个新的Observable。flatMap和map操作符很相像，flatMap发送的是合并后的Observables，map操作符发送的是应用函数后返回的结果集。

还有一些重载方法以后再说

Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onNext("1");
        emitter.onNext("2");
        emitter.onNext("3");
        emitter.onNext("4");
        emitter.onComplete();
    })
    .flatMap((Function<String, ObservableSource<Integer>>) s -> {
        Log.e("=================", "==apply==>" + s);//1,2,3,4
        int apply = Integer.valueOf(s);
        return apply > 2 ? Observable.create(emitter -> {
            emitter.onNext(2);
            emitter.onComplete();
        }) : Observable.create(emitter -> {
            emitter.onNext(1);
            emitter.onComplete();
        });
    })
    .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Integer integer) {
            Log.e("=================", "==onNext==>" + integer);//1,1,2,2
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {
            Log.e("=================", "==onComplete==>");
        }
    });

3、concatMap操作符

与flatMap操作符功能相同

与flatMap操作符的区别：flatMap操作符

4、switchMap操作符

当源Observable发射一个新的数据项时，如果旧数据项订阅还未完成，就取消旧订阅数据和停止监视那个数据项产生的Observable,开始监视新的数据项.

5、cast操作符

cast操作符将原始Observable发射的每一项数据都强制转换为一个指定的类型，然后再发射数据，它是map的一个特殊版本。相互转换的数据之间存在继承关系。

6、concat操作符

组合多个被观察者一起发送数据，合并后按发送顺序串行执行

7、merge操作符

组合多个被观察者一起发送数据，合并后按时间线并行执行

8、zip操作符

合并多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送

9、reduce操作符

把被观察者要发送的事件聚合成一个事件发送。

10、collect操作符

将被观察者Observable发送的数据事件收集到一个数据结构里

11、startWith操作符

在一个被观察者发送事件前，追加发送一些数据或是一个新的被观察者

12、compose操作符

lift() 是针对事件项和事件序列的，而 compose() 是针对 Observable 自身进行变换。

Observable
    .create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            emitter.onNext("aaa");
            emitter.onNext("bbb");
            emitter.onNext("ccc");
            emitter.onComplete();
        }
    })
    .compose(new ObservableTransformer<String, String>() {
        @Override
        public ObservableSource<String> apply(Observable<String> upstream) {
            return upstream.takeLast(1);
        }
    })
    .subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(String s) {
            Log.e("===========", "====>" + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e("===========", "====>" + e.toString());
        }

        @Override
        public void onComplete() {

        }
    });

compose将上游的Observable对象传递到apply()方法中，在apply()方法中添加变换，并返回当前Observable对象。

13、lift操作符

在 Observable 执行了lift(Operator) 方法之后，会创建一个ObservableLift对象并返回。在ObservableLift代理对象中将订阅ObservableLift的observer传递到operator的apply方法中，贴上源码：

@Override
    public void subscribeActual(Observer<? super R> observer) {
        Observer<? super T>  liftedObserver = ObjectHelper.requireNonNull(operator.apply(observer), "Operator " + operator + " returned a null Observer");
        source.subscribe(liftedObserver);
    }

然后，将apply()方法返回的Observer对象订阅初始Observable对象。

Observable
    .create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            emitter.onNext("1");
            emitter.onNext("2");
            emitter.onNext("3");
            emitter.onComplete();
        }
    })
    .lift(new ObservableOperator<Integer, String>() {
        @Override
        public Observer<? super String> apply(Observer<? super Integer> observer) throws Exception {
            return new Observer<String>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(String s) { Log.e("============","===apply==>"+s); observer.onNext(Integer.parseInt(s));
                }

                @Override
                public void onError(Throwable e) { Log.e("============","===apply==>onError");
                    observer.onError(e);
                }

                @Override
                public void onComplete() { Log.e("============","===apply==>onComplete");
                    observer.onComplete();
                }
            };
        }
    })
    .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Integer integer) {
            Log.e("============","===integer==>"+integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e("============","===integer==>onError");
        }

        @Override
        public void onComplete() {
            Log.e("============","===integer==>onComplete");
        }
    });

=apply>1
=integer>1
=apply>2
=integer>2
=apply>3
=integer>3
=apply>onComplete
=integer>onComplete

三、empty操作符

创建一个Observable对象并直接发送Complete事件，订阅完成。

Observable
    .empty()
    .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(Object o) {
            Log.e("=========", "===onNext==>" + o);
        }
        @Override
        public void onError(Throwable e) {
            Log.e("=========", "===onError==>" + e);
        }
        @Override
        public void onComplete() {
            Log.e("=========", "===onComplete==>");
        }
    });

打印结果：

 ===onComplete==>

四、error操作符

创建一个Observable对象并发送Error事件

Observable
    .error(new RuntimeException())
    .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(Object o) {
            Log.e("=========", "===onNext==>" + o);
        }
        @Override
        public void onError(Throwable e) {
            Log.e("=========", "===onError==>" + e);
        }
        @Override
        public void onComplete() {
            Log.e("=========", "===onComplete==>");
        }
    });

打印结果：

 ===onError==>java.lang.RuntimeException

五、never操作符

创建一个Observable对象但不发送任何事件

六、延时操作符

定时操作：在经过了x秒后，需要自动执行y操作
周期性操作：每隔x秒后，需要自动执行y操作

1、delay操作符

使被观察者延迟一段时间再发送事件

//参数一：延迟时间数，参数二：时间单位
delay(long delay, TimeUnit unit)
//错误延迟：即：若发生error事件则正常执行，执行完再执行error事件；若不设置，则发生error事件时会直接抛出error事件，不会执行延时事件
//参数一：延迟时间数，参数二：时间单位，参数三：错误延迟
delay(long delay, TimeUnit unit, boolean delayError)
//参数一：延迟时间数，参数二：时间单位，参数三：线程调度器，改变下游观察者的执行线程
delay(long delay, TimeUnit unit, Scheduler scheduler)
//参数一：延迟时间数，参数二：时间单位，参数三：线程调度器，参数四：错误延迟
delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)

2、timer操作符

创建一个Observable对象
延迟指定时间后发送一个0（Long型）给观察者
timer默认运行在子线程中，可指定运行线程

    long l=System.currentTimeMillis()/1000;
    Observable
        .timer(10,TimeUnit.SECONDS)
        //可以指定线程
        //timer(long delay, TimeUnit unit, Scheduler scheduler)
        .subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(Long o) {
                Log.e("=========", "===onNext==>" + o);
                Log.e("=========", "===onNext==>" + (System.currentTimeMillis()/1000-l));
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
    });

打印结果：

 ===onNext==>0
 ===onNext==>10

3、interval操作符

创建一个Observable对象
每隔指定时间发送一个事件，发送给观察者的参数有0不断递增，即每次加一
interval默认运行在子线程中，可指定运行线程

Observable
    .interval(3,TimeUnit.SECONDS)
    .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(Long o) {
            Log.e("=========", "===onNext==>" + o);
        }
        @Override
        public void onError(Throwable e) {
        }
        @Override
        public void onComplete() {
        }
    });

每隔3秒发送一条数据给观察者，数据为：0，1，2，3，…

4、range、rangeLong操作符

快速创建一个Observable对象
发送一个时间序列，指定开始值和发送数量
range与rangeLong的区别是：range发送的是Integer型,rangeLong发送的是Long型

range(final int start, final int count)
rangeLong(long start, long count)

defer操作符

七、过滤操作符

1. take,takeLast

 // 并不是取第n个，而是取前面n个数据
 take(n) 
 // 是在指定时间内取数据，如果超过了这个时间源Observable产生的数据将作废
 take(long time, TimeUnit unit)

2. skip, skipFirst, skipLast

//跳过前面几项
skip(int count)
// 跳过前面的时间，之后产生的数据提交
skip(long time, TimeUnit unit)
// skipLast和skip相反，跳过后面的几项。
// 忽略最后时间单位内产生的数据
skipLast(long time,TimeUnit)

3. first

first操作符，取发射的第一个数据，没有则发射默认值

4. last

last操作符和takeLast操作符相似，takeLast取发射的后几个数据，last取发射的最后一个数据，没有则发射默认值
区别：takeLast没有默认值，last可以设置默认值

5. firstOrDefault, lastOrDefault

只发射最后一项（或者满足某个条件的最后一项）数据，可以指定默认值。

5、filter

过滤数据，不满足条件的数据将被过滤不发射。

    //自定义过滤条件
    filter(new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) throws Exception {
            return false;
        }
    })

6、ofType

过滤指定类型的数据

Observable.just(1,2,3,4,"a","b")
                .ofType(Integer.class)
                .subscribe(integer -> {
                    Log.e("===========", "===>" + integer);
                });

打印结果：

    ===>1
    ===>2
    ===>3
    ===>4

ofType过滤Integer以外的数据

7、elementAt/elementAtOrError操作符

发射某一项数据，如果超过了范围可以指定默认值。内部通过OperatorElementAt过滤。

区别：
elementAt：指定发射上游Observable传过来的第几项值，可以指定默认值，超过范围时发送默认值，若没指定默认值则不发送，直接调用onComplete()方法
elementAtOrError：指定发射上游Observable传过来的第几项值，超过范围时调用onError()方法,错误:java.util.NoSuchElementException

Observable.just(2, 4, 6, 8, 10)
//  .elementAtOrError(3)
    .elementAt(3)
    .subscribe(integer -> {
        Log.e("=========", "=====>" + integer);//8
    });

8、firstElement/lastElement操作符

发射上游Observable传过来的第一项值/最后一项值

Observable.just(2, 4, 6, 8, 10)
//      .firstElement()
        .lastElement()
        .subscribe(integer -> {
            Log.e("=========", "=====>" + integer);
        });

9、ignoreElements操作符

丢弃所有数据，只发射错误或正常终止的通知。内部通过OperatorIgnoreElements实现。

10、distinct/distinctUntilChanged操作符

distinct：过滤重复数据，内部通过OperatorDistinct实现。
distinctUntilChanged：过滤连续重复数据，内部通过OperatorDistinctUntilChanged实现

11、timeout操作符

如果原始Observable过了指定的一段时长没有发射任何数据，就发射一个异常(java.util.concurrent.TimeoutException)或者使用备用的Observable。

12、Debounce/throttleWithTimeout操作符

根据你指定的时间间隔进行限流
发送数据事件时，若2次发送事件的间隔＜指定时间，就会丢弃前一次的数据，直到指定时间内都没有新数据发射时才会发送后一次的数据

//源码：
public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit) {
        return debounce(timeout, unit);
}
public final Observable<T> throttleWithTimeout(long timeout, TimeUnit unit, Scheduler scheduler) {
        return debounce(timeout, unit, scheduler);
}
public final Observable<T> debounce(long timeout, TimeUnit unit) {
        return debounce(timeout, unit, Schedulers.computation());
}
public final Observable<T> debounce(long timeout, TimeUnit unit, Scheduler scheduler) {
        ObjectHelper.requireNonNull(unit, "unit is null");
        ObjectHelper.requireNonNull(scheduler, "scheduler is null");
        return RxJavaPlugins.onAssembly(new ObservableDebounceTimed<T>(this, timeout, unit, scheduler));
}

八、条件操作符

1、single/singleOrError操作符

检测源Observable发送的数据项是否只有一个，否则报错：java.lang.IllegalArgumentException: Sequence contains more than one element!

public final Single<T> single(T defaultItem) {
        ObjectHelper.requireNonNull(defaultItem, "defaultItem is null");
    return RxJavaPlugins.onAssembly(new ObservableSingleSingle<T>(this, defaultItem));
}
public final Single<T> singleOrError() {
    return RxJavaPlugins.onAssembly(new ObservableSingleSingle<T>(this, null));
}

注：
single()方法可以设置一个默认值，当上游Observable发送的值为null时默认发送这个默认值。（但是，当上游发送null时报错：java.lang.NullPointerException: onNext called with null. Null values are generally not allowed in 2.x operators and sources.）

2、all操作符

all操作符接收一个函数参数，创建并返回一个单布尔值的Observable,如果原Observable正常终止并且每一项数据都满足条件，就返回true,如果原Observable的任何一项数据不满足条件或者非正常终止就返回false。

Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onNext("aaa");
        emitter.onNext("bbb");
        emitter.onNext("ccc");
        emitter.onComplete();
    })
    .all(s -> {
        //自己判断上游Observable传递过来的数据是否满足条件，满足返回true,不满足返回false。返回false之后会终止数据发送。
        Log.e("=========", "====all=>" + s);
        return true;
    })
    .subscribe(new SingleObserver<Boolean>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onSuccess(Boolean aBoolean) {
            Log.e("=========", "====onSuccess=>" + aBoolean);
        }

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

3、amb/ambArray操作符

amb操作符对于给定两个或多个Observables，它只发射首先发射数据或通知的那个Observable的所有数据。

Observable<String> observable1 = Observable
                .create((ObservableOnSubscribe<String>) emitter -> {
                    emitter.onNext("aaa");
                    emitter.onNext("bbb");
                    emitter.onNext("ccc");
                    emitter.onComplete();
                });
        Observable<String> observable2 = Observable
                .create((ObservableOnSubscribe<String>) emitter -> {
                    emitter.onNext("111");
                    emitter.onNext("222");
                    emitter.onNext("333");
                    emitter.onComplete();
                });
        List<ObservableSource<String>> observableSources = new ArrayList<>();
        observableSources.add(observable2);
        observableSources.add(observable1);
//        Observable.amb(observableSources)
        Observable.ambArray(observable1, observable2)
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String t) {
                        Log.e("=============", "===onNext==>" + t);
                    }

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

                    @Override
                    public void onComplete() {
                        Log.e("=============", "===onComplete==>");
                    }
                });

4、contains操作符

contains操作符将接收一个特定的值作为一个参数，判定原Observable是否发射该值，若已发射，则创建并返回的Observable将发射true，否则发射false。

Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onNext("aaa");
        emitter.onNext("1234");
        emitter.onNext("ccc");
        emitter.onComplete();
    })
    .contains("1234")
    .subscribe(new SingleObserver<Boolean>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onSuccess(Boolean aBoolean) {//true
            Log.e("===========", "====>" + aBoolean);
        }

        @Override
        public void onError(Throwable e) {

        }
    });

5、isEmpty操作符

isEmpty操作符用于判定原始Observable是否没有发射任何数据。若原Observable未发射任何数据，创建创建并返回一个发射true的Observable，否则返回一个发射false的Observable。

可以用来判断是否发射数据。

Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onComplete();
    })
    .isEmpty()
    .subscribe(new SingleObserver<Boolean>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onSuccess(Boolean aBoolean) {
            //true
            Log.e("===========", "====>" + aBoolean);
        }

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

6、defaultIfEmpty操作符

defaultIfEmpty接收一个备用数据，在原Observable没有发射任何数据正常终止（以onComplete的形式）时，该操作符创建一个Observable并将备用数据发射出去。

内部调用的是switchIfEmpty

Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onComplete();
    })
    .defaultIfEmpty("默认/备用")
    .subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(String ss) {//默认/备用
            Log.e("===========", "==onNext==>" + ss);
        }

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

        @Override
        public void onComplete() {
            Log.e("===========", "==onComplete==>");
        }
    });

7、switchIfEmpty操作符

switchIfEmpty内部添加一个备用Observable。如果原始Observable没有发射任何数据正常终止，就使用备用的Observable。

Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
//                    emitter.onNext("hhh");
        emitter.onComplete();
    })
    .switchIfEmpty(observer -> {
        observer.onNext("默认值");
        observer.onComplete();
    })
    .subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(String ss) {//默认值
            Log.e("===========", "==onNext==>" + ss);
        }

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

        @Override
        public void onComplete() {
            Log.e("===========", "==onComplete==>");
        }
    });

8、sequenceEqual操作符

sequenceEqual(Observable,Observable)接收两个Observable参数，内部默认比较两个Observable发送的数据是否相同(顺序不同也是不同)
sequenceEqual(Observable,Observable,Func2)接收两个Observable参数和一个函数参数，在函数参数中，可以自定义比较两个参数。

若其中一个Observable没有发送数据，则需要调用onComplete()下游观察者才会得到比较结果false,都没有发送是true.

Observable
    .sequenceEqual((ObservableSource<String>) observer -> {
        observer.onNext("aaa");
        observer.onNext("ccc");
        observer.onComplete();
    }, observer -> {
        observer.onNext("ccc");
        observer.onNext("aaa");
        observer.onComplete();
    }, (s, s2) -> {
        return s.equals(s2);
    })
    .subscribe(new SingleObserver<Boolean>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e("=========", "==onSubscribe==>");
        }

        @Override
        public void onSuccess(Boolean aBoolean) {
            Log.e("=========", "==onSuccess==>" + aBoolean);
        }

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

9、skipUntil/skipWhile操作符

skipUntil操作符在观察者订阅原Observable时，该操作符将是忽略原Observable的发射的数据，直到第二个Observable发射了一项数据那一刻，它才开始发射原Observable发射的数据。
skipWhile操作符丢弃原Observable发射的数据，直到发射的数据不满足一个指定的条件，才开始发射原Observable发射的数据。(在观察者订阅原Observable时，skipWhile操作符将忽略原Observable的发射物，直到你指定的某个条件变为false时，它开始发射原Observable发射的数据。)

10、takeUntil/takeWhile操作符

takeUntil操作符与skipUntil操作符作用相反，当第二个Observable发射了一项数据或者终止时，丢弃原Observable发射的任何数据。takeUntil(Func1)接受一个函数参数，当满足条件时终止发射数据。
takeWhile操作符与skipWhile操作符作用相反。在观察者订阅原Observable时，takeWhile创建并返回原Observable的镜像Observable，暂命名为_observable，发射原Observable发射的数据。当你指定的某个条件变为false时，_observable发射onCompleted终止通知。

九、其它

1、retry操作符

重试，即当出现错误时，让被观察者（Observable）重新发射数据

i = 0;
Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onNext("aaa");
        if (i == 0) {
            emitter.onError(new RuntimeException());
        } else {
            emitter.onComplete();
        }
        i++;
    })
    .retry()
    .subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(String s) {
            Log.e("=============", "==onNext==>" + s);
        }
        @Override
        public void onError(Throwable e) {
            Log.e("=============", "==onError==>" + e);
        }
        @Override
        public void onComplete() {
            Log.e("=============", "==onComplete==>");
        }
    });

==onNext==>aaa
==onNext==>aaa
==onComplete==>

2、retryUntil操作符

出现错误后，判断是否需要重新发送数据

i = 0;
Observable
    .create((ObservableOnSubscribe<String>) emitter -> {
        emitter.onNext("aaa");
        if (i == 0) {
            emitter.onError(new RuntimeException());
        } else {
            emitter.onComplete();
        }
        i++;
    })
    //返回true表示不需要重新发送，false需要重新发送
    .retryUntil(() -> true)
    .subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
        }
        @Override
        public void onNext(String s) {
            Log.e("=============", "==onNext==>" + s);
        }
        @Override
        public void onError(Throwable e) {
            Log.e("=============", "==onError==>" + e);
        }
        @Override
        public void onComplete() {
            Log.e("=============", "==onComplete==>");
        }
    });

3、retryWhen操作符

遇到错误时，将发生的错误传递给一个新的被观察者（Observable），并决定是否需要重新订阅原始被观察者（Observable）及发送事件

4、repeat操作符

无条件地，重复发送被观察者事件

5、repeatUntil操作符

有条件地，判断是否需要重复发送被观察者事件

 Observable
        .create((ObservableOnSubscribe<String>) emitter -> {
            emitter.onNext("hhh");
            emitter.onComplete();
        })
        //返回true表示不需要重复发送，返回false表示需要重复发送
        .repeatUntil(() -> true)
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                Log.e("=============", "==onNext==>"+s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.e("=============", "==onComplete==>");
            }
        });