RxJava操作符简记

官方文档

RxAndroid源码

ProgressOn思维导图
image

一、创建操作符

1、create操作符

创建一个被观察者Observable对象

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
    }
});
2、just操作符
  1. 快速创建一个被观察者Observable对象
  2. 创建完成之后直接将just()方法的参数发送给观察者
  3. 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==>");
            }
        });
6、repeatWhen操作符

有条件地,重复发送被观察者事件

7、count 操作符

统计被观察者发送事件的数量

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值