rxjava操作符笔记及爬坑总结（持续更新中...）

最新推荐文章于 2021-02-25 15:52:20 发布

原创最新推荐文章于 2021-02-25 15:52:20 发布 · 380 阅读

0 ·

CC 4.0 BY-SA版权

安卓专栏收录该内容

31 篇文章

订阅专栏

本文详细介绍了RxJava中六种常用操作符的功能及应用场景，包括zipWith用于同步处理两个Observable的结果，mergeWith用于独立处理两个Observable的结果，concatWith用于按顺序处理多个Observable，flatMap用于嵌套处理Observable，map用于转换结果值，以及filter用于过滤数据。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.如果你需要同时拿到两个Observable的结果来处理，可以使用zipWith（o1.zipWith(o2).subscribe(subscriber)）；经测试，两个Observable的发射次数一一对应，如果不一致，则发射完少的就不会再发射了。不要求类型一致。等同于zip写法不同。

Observable.just("hello","good").zipWith(Observable.just(2), new Func2<String, Integer, String>() {
            @Override
            public String call(String s, Integer s2) {
                return s+" "+String.valueOf(s2);
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                String s = e.toString();
            }

            @Override
            public void onNext(String s) {
                String s1 = s;
            }
        });

2.如果是单独处理两个Observable的结果，相互之间没有关系，可以用mergeWith（o1. mergeWith(o2).subscribe(subscriber)）；经测试，结果各自处理，但是要确保两个Observable的泛型类型一致。等同于merge，写法不同。

Observable.just("a","c").mergeWith(Observable.just("str")).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                String str = s;
            }
        });

3.如果是有顺序要求，要先处理第一个Observable的结果，再处理第二个，可以用concatWith（o1. concatWith(o2).subscribe(subscriber)）。要求类型一致，输出有先后顺序。等同于concat。

Observable.just("a").concatWith(Observable.just("kkk")).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
        });

4.如果需要先处理第一个Observable结果，然后把第一个的结果作为第二个Observable的参数传入，可以用o1.flatMap(new Func1(a,b){return a->b}).subscriber。a代表o1的结果类型，b代表o2的结果类型，在Func1方法中把a转换成b返回，在subscribe中处理的是b类型。如例子所示，传入的是String类型的字符“a”，在flatMap转换成hash值97输出。

Observable.just("a").flatMap(new Func1<String, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(String s) {
                return Observable.just(s.hashCode());
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                int i = integer;
            }
        });

5.如果只是需要对结果值进行转换，用01.map(new Func1(a,b){a->b}).subscribe就可以。

Observable.just("a").map(new Func1<String, Integer>() {
            @Override
            public Integer call(String s) {
                return s.hashCode();
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {
                int a = integer;
            }
        });

咋一看4,5好像没什么区别，都是String转int，但是其实差别还是很大的，4使用了Observable的嵌套处理，而5只是简单地对结果进行了处理，可能有人会问这有什么用呢？试想一种场景，我们需要利用retrofit获取一个验证ID，然后通过这个ID再进行数据请求，那么这个时候就需要用到嵌套了，而且这种嵌套是可以一直持续下去的。

6.如果想对数据进行简单过滤，可以使用01.filter(new Func1(a,Boolean){return Boolean}).subscribe。

Observable.just("a","b").filter(new Func1<String, Boolean>() {
            @Override
            public Boolean call(String s) {
                if(s.equals("a")){
                    return true;
                }
                return false;
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
        });

其实filter跟map挺像的，顾名思义，filter通过条件过滤返回布尔值，只有为true时当前事件才被发射出去，而map更侧重变换。

注意事项：

1.subject的观察者调用必须在被观察者后面，否则得不到任何信息。

 Subject<Object, Object> subject = new SerializedSubject<>(PublishSubject.create());
        1.Subscription s =  subject.subscribe(new Observer<Object>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                Log.e("rxjava", o.toString());
            }
        });
       2. subject.onNext("dongxi");

这里的1,2不能置换顺序，否则会导致监听丢失。所以使用Subject的时候，我们必须小心翼翼地设计程序，确保消息发送的时机是在Subscriber已经Ready的时候，否则我们就很容易错过我们关心的事件。