RxJava使用详解--组合操作符

最新推荐文章于 2024-01-22 11:30:00 发布
最新推荐文章于 2024-01-22 11:30:00 发布
阅读量4k 收藏 2
点赞数
分类专栏： RxJava 文章标签： rxjava zip merge
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaochuanding/article/details/53761207
版权

RxJava使用详解系列文章

《RxJava使用详解--创建操作符》

《RxJava使用详解--转换操作符》

《RxJava使用详解--过滤操作符》


详细的例子可以查看文章末尾的源码


这篇文章主要讲RxJava中常见的组合操作符


1.combineLatest操作符把两个Observable产生的结果进行合并，合并的结果组成一个新的Observable。下面的栗子是ob2中的每一个数据项都与ob1中的最后一项进行相加，将生成的结果组成一个新的Observable对象.

combineLatest操作符可以接受2-9个Observable作为参数，最后一个Observable中的每一个数据项，都与前面Observable中的最后一项进行规则运算。也就是call方法中的最后一个值参数是最后一个Observable的每一项数据，
前面的参数是前面每一个Observable的最后一项数据，固定不变的。
combineLatest(List,FuncN)操作符可以接受一个Observable的list集合，集合中最后一个Observable中的每一项数据，会跟前面每一个Observable对象的最后一项数据进行规则运算
默认不在任何特定的调度器上执行。



Observable<Integer> ob1 = Observable.just(1,2,3);
Observable<Integer> ob2 = Observable.just(4,5,6);
Observable<Integer> ob3 = Observable.just(7,8,9);

List<Observable<Integer>> list = new ArrayList<>();
list.add(ob1);list.add(ob2);list.add(ob3);

Observable.combineLatest(ob1, ob2, new Func2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer integer, Integer integer2) {
        System.out.println("combineLatest(o1,o2,Func2):"+"o1:" + integer +" o2:"+ integer2 );
        return integer + integer2;//这里进行合并的规则，可以用函数进行运算返回一个数据
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("combineLatest(o1,o2,Func2) onNext:" + integer);
    }
});
输出结果：
combineLatest(o1,o2,Func2):o1:3 o2:4
combineLatest(o1,o2,Func2) onNext:7
combineLatest(o1,o2,Func2):o1:3 o2:5
combineLatest(o1,o2,Func2) onNext:8
combineLatest(o1,o2,Func2):o1:3 o2:6
combineLatest(o1,o2,Func2) onNext:9

Observable.combineLatest(ob1, ob2, ob3, new Func3<Integer, Integer, Integer, Integer>() {
    @Override//这里进行合并的规则，可以用函数进行运算返回一个数据
    public Integer call(Integer integer, Integer integer2, Integer integer3) {
        System.out.println("combineLatest(o1,o2,o3,Func3):"+"o1:" + integer +" o2:"+ integer2 +" o3:"+ integer3);
        return integer + integer2 + integer3;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("combineLatest(o1,o2,o3,Func3) onNext:" + integer);
    }
});
输出结果：
combineLatest(o1,o2,o3,Func3):o1:3 o2:6 o3:7
combineLatest(o1,o2,o3,Func3) onNext:16
combineLatest(o1,o2,o3,Func3):o1:3 o2:6 o3:8
combineLatest(o1,o2,o3,Func3) onNext:17
combineLatest(o1,o2,o3,Func3):o1:3 o2:6 o3:9
combineLatest(o1,o2,o3,Func3) onNext:18

Observable.combineLatest(list, new FuncN<String>() {
    @Override//这里进行合并的规则，可以用函数进行运算返回一个数据
    public String call(Object... args) {
        String concat = "";
       for (Object value : args){
           System.out.println("combineLatest(List,FuncN) value:" + value);
           concat += value;
       }
        return concat;
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println("combineLatest(List,FuncN) onNext:" + s);
    }
});
输出结果：
combineLatest(List,FuncN) value:3
combineLatest(List,FuncN) value:6
combineLatest(List,FuncN) value:7
combineLatest(List,FuncN) onNext:367
combineLatest(List,FuncN) value:3
combineLatest(List,FuncN) value:6
combineLatest(List,FuncN) value:8
combineLatest(List,FuncN) onNext:368
combineLatest(List,FuncN) value:3
combineLatest(List,FuncN) value:6
combineLatest(List,FuncN) value:9
combineLatest(List,FuncN) onNext:369

2.join操作符将两个Observable产生的结果合并成一个新Observable对象，join操作符可以控制每个Observable产生结果的生命周期。
参数解释 ob1.join(ob2,ob1产生结果生命周期控制函数，ob2产生结果生命周期控制函数，ob1和ob2合并结果的规则)
groupJoin()操作符第四个参数与join操作符不同，详细的运行栗子查看


Observable<Integer> ob1 = Observable.just(1,2);
Observable<Integer> ob2 = Observable.just(3,4);
//join操作符
ob1.join(ob2, new Func1<Integer, Observable<Integer>>() {//ob1产生结果生命周期控制函数
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob1延迟200毫秒执行
        return Observable.just(integer).delay(200, TimeUnit.MILLISECONDS);
    }
}, new Func1<Integer, Observable<Integer>>() {//ob2产生结果声明周期控制函数
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob2延迟200毫秒执行
        return Observable.just(integer).delay(200, TimeUnit.MILLISECONDS);
    }
}, new Func2<Integer, Integer, Integer>() {//ob1 和ob2产生结果的合并规则
    @Override
    public Integer call(Integer integer1, Integer integer2) {
        System.out.println("join(ob2,Func1,Func1,Func2) " + "integer1:" +integer1+ " integer2:" + integer2);
        return integer1 + integer2;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("join(ob2,Func1,Func1,Func2) " + integer);
    }
});
输出结果：
join(ob2,Func1,Func1,Func2) integer1:1 integer2:3
join(ob2,Func1,Func1,Func2) 4
join(ob2,Func1,Func1,Func2) integer1:2 integer2:3
join(ob2,Func1,Func1,Func2) 5
join(ob2,Func1,Func1,Func2) integer1:1 integer2:4
join(ob2,Func1,Func1,Func2) 5
join(ob2,Func1,Func1,Func2) integer1:2 integer2:4
join(ob2,Func1,Func1,Func2) 6

//groupJoin操作符
ob1.groupJoin(ob2, new Func1<Integer, Observable<Integer>>() {//ob1产生结果生命周期控制函数
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob1延迟1600毫秒执行
        return Observable.just(integer).delay(1600, TimeUnit.MILLISECONDS);
    }
}, new Func1<Integer, Observable<Integer>>() {//ob2产生结果声明周期控制函数
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob2延迟600毫秒执行
        return Observable.just(integer).delay(600, TimeUnit.MILLISECONDS);
    }
}, new Func2<Integer, Observable<Integer>, Observable<Integer>>() {
    @Override
    public Observable<Integer> call(final Integer integer1, Observable<Integer> observable) {
        return observable.map(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer2) {
                System.out.println("groupJoin(ob2,Func1,Func1,Func2) " + "integer1:" + integer1 + " integer2:" + integer2);
                return integer1 + integer2;
            }
        });
    }
}). subscribe(new Action1<Observable<Integer>>() {
    @Override
    public void call(Observable<Integer> observable) {
        observable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("groupJoin(ob2,Func1,Func1,Func2) onNnext:" + integer);
            }
        });
    }
});
输出结果：
groupJoin(ob2,Func1,Func1,Func2) integer1:1 integer2:3
groupJoin(ob2,Func1,Func1,Func2) onNnext:4
groupJoin(ob2,Func1,Func1,Func2) integer1:2 integer2:3
groupJoin(ob2,Func1,Func1,Func2) onNnext:5
groupJoin(ob2,Func1,Func1,Func2) integer1:1 integer2:4
groupJoin(ob2,Func1,Func1,Func2) onNnext:5
groupJoin(ob2,Func1,Func1,Func2) integer1:2 integer2:4
groupJoin(ob2,Func1,Func1,Func2) onNnext:6
3.merge操作符 将多个Observalbe发射的数据项，合并到一个Observable中再发射出去，可能会让合并的Observable发射的数据交错（concat是连接不会出现交错），如果在合并的途中出现错误，就会立即将错误提交给订阅者，将终止合并后的Observable 
mergeDelayError操作符类似于merge操作符，唯一不同就是如果在合并途中出现错误，不会立即发射错误通知，而是保留错误直到合并后的Observable将所有的数据发射完成，
此时才会将onError提交给订阅者。
合并多个Observable也可以通过传递一个Observalbe列表List、数组。

Observable<Integer> ob1 = Observable.just(1,2,3).delay(100, TimeUnit.MILLISECONDS);
Observable<Integer> ob2 = Observable.just(4,5,6)/*.delay(100, TimeUnit.MILLISECONDS)*/;

Observable.merge(ob1,ob2).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("merge(ob1,ob2) onNext:" + integer);
    }
});
输出结果：

12-20 13:18:42.341 31603-31603/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:4
12-20 13:18:42.341 31603-31603/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:5
12-20 13:18:42.341 31603-31603/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:6
12-20 13:18:42.440 31603-31672/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:1
12-20 13:18:42.441 31603-31672/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:2
12-20 13:18:42.441 31603-31672/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:3


4.startWith操作符是在源Observable提交结果之前插入指定的数据，可以是数值，也可以是Observable对象


Observable.just(1,2,3).startWith(0).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("startWith(T) onNext:" + integer);
    }
});
System.out.println(" - - - - - -  - - ");
Observable<Integer> ob2 = Observable.just(4,5,6);
Observable.just(1,2,3).startWith(ob2).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("startWith(T) onNext:" + integer);
    }
});
输出结果：

startWith(T) onNext:0
startWith(T) onNext:1
startWith(T) onNext:2
startWith(T) onNext:3
 - - - - - -  - -
startWith(T) onNext:4
startWith(T) onNext:5
startWith(T) onNext:6
startWith(T) onNext:1
startWith(T) onNext:2
startWith(T) onNext:3


5.switchOnNext操作符是把一组Observable转换成一个Observable，转换规则为：对于这组Observable中的每一个Observable所产生的结果，如果在同一个时间内存在两个或多个Observable提交的结果，只取最后一个Observable提交的结果给订阅者（看源码中的例子）



6.zip操作符严格按照顺序进行组合Observable，假设两个Observable合并，ob1发射2个数据，ob2发射3个数据，最终合并的胡发射2个合并的数据。

zipWith操作符与上面类似，具体的看下面的例子
默认不在特定的调度器上执行




Observable<Integer> ob1 = Observable.just(1,2,3);
Observable<Integer> ob2 = Observable.just(4,5,6);

Observable.zip(ob1, ob2, new Func2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer integer1, Integer integer2) {
        System.out.println("zip(ob1,ob2,Func2) integer1:" + integer1 +" integer2:"+integer2);
        return integer1 + integer2;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("zip(ob1,ob2,Func2) onNext:" + integer);
    }
});
System.out.println("- - - - - - - -");
ob1.zipWith(ob2, new Func2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer integer1, Integer integer2) {
        System.out.println("ob1.zipWith(ob2,Func2) integer1:" + integer1 +" integer2:"+integer2);
        return integer1 + integer2;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("ob1.zipWith(ob2,Func2)  " + integer );
    }
});
输出结果：

zip(ob1,ob2,Func2) integer1:1 integer2:4
zip(ob1,ob2,Func2) onNext:5
zip(ob1,ob2,Func2) integer1:2 integer2:5
zip(ob1,ob2,Func2) onNext:7
zip(ob1,ob2,Func2) integer1:3 integer2:6
zip(ob1,ob2,Func2) onNext:9
- - - - - - - -
ob1.zipWith(ob2,Func2) integer1:1 integer2:4
ob1.zipWith(ob2,Func2)  5
ob1.zipWith(ob2,Func2) integer1:2 integer2:5
ob1.zipWith(ob2,Func2)  7
ob1.zipWith(ob2,Func2) integer1:3 integer2:6
ob1.zipWith(ob2,Func2)  9

更多详细内容和例子，可以查看源码

钉某人
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Rxjava功能操作符的使用方法详解
08-28
主要介绍了Rxjava功能操作符的使用方法详解，还是比较不错的，这里分享给大家，供需要的朋友参考。
C语言基础-操作符详解
12-30
C语言基础-操作符详解
RxJava（十二）combineLatest 操作符的高级使用
Chiclaim
03-10 8185
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
RxJava CombineLatest
new_abc的专栏
11-21 589
直接上demo Observable observable1 = Observable.interval(1, TimeUnit.SECONDS); Observable observable2 = Observable.interval(2, TimeUnit.SECONDS); Observable observable3 = Observa...
RxJava操作符(4)-结合
DylanZhuang的博客
08-13 675
RxJava现在感觉挺火的，这段时间就抽空学习了RxJava相关API。在网上也看到过RxJava相关文章，总感觉看了好多遍也记不住，于是就打算用博客记下来，毕竟好记性不如烂笔头，下面介绍下结合操作符。
RxJava - combineLatest操作符
Restless Breeze
07-15 457
combineLatest()作用于最近发射的数据项，在其中一个Observable发射数据项后，组合所有Observable所发射的最后一个数据项（前提是所有的Observable都至少发射过一个数据项）,如下图所示; 其原理即：如果Observable1发射了1,接着Observable2发射了A，combineLatest()将会处理1和A，组合成1A；而Observable1发射了2，此时Observable2只发射了A，所以combineLatest()将处理2和A，组合成2A；待Obser
5. RxJava合并条件操作符
NorthStar的博客
07-30 1075
RxJava合并条件操作符
UCOS-II操作系统详解.doc
11-15
UCOS-II操作系统详解.doc
软件开发过程详解-.pdf
11-17
软件开发过程详解-.pdf
DF无线数据模块使用详解-综合文档
05-23
DF无线数据模块使用详解
用RxJava处理复杂表单验证问题
weixin_30408739的博客
06-12 178
用RxJava处理复杂表单验证问题 无论是简单的登录页面，还是复杂的订单提交页面，表单的前端验证（比如登录名和密码都符合基本要求才能点亮登录按钮）都是必不可少的步骤。本文展示了如何用RxJava来方便的处理表单提交前的验证问题，例子采用了Android上的一个简单的登录页面 内容提要 传统的验证方式 combineLatest操作符 用combineLatest处理表单验证 combineL...
RxJava2从入门到精通-初级篇
11-08
适合所有初中级工程师，从RxJava的每个知识点进行讲解，并在每个知识点中都带有文字说明和代码例子说明。通过这次系统化的学习，您将可以完整的学习到RxJava家族的所有特性和常用的操作符，掌握操作符的使用，掌握RxJava与Rx其他第三方库的使用。可以用三句简单的话进行概括面试加分利器 = 加大录取机会加快工作效率 = 早点下班回家系统化的学习 = 能力全面提升
Combine 操作符对比剖析 —— merge、zip 和 combineLatest
刘铎Derek在CSDN
04-10 487
综上所述，merge、zip 和 combineLatest 操作符都是非常有用的操作符，它们可以将多个 Publisher 合并成一个，以便更方便地处理和订阅。merge 操作符可以将多个 Publisher 合并成一个，并按照它们产生事件的顺序将这些事件发送给下游；zip 操作符可以将多个 Publisher 合并成一个，并将它们产生的事件配对发送给下游；combineLatest 操作符可以将多个 Publisher 合并成一个，并将它们产生的最新事件进行组合发送给下游。
rxjs中combineLatest的用法
zwjapple的专栏
11-22 162
操作符可以用于将多个Observable对象合并成一个新的Observable对象，新的Observable对象的值是由原始Observable对象的最新值组成的一个数组。当任何一个原始Observable对象发出新值时，新的Observable对象的值也会更新。当新的Observable对象发出新值时，我们通过解构赋值获取输入框A和输入框B的最新值，然后根据这些值来判断按钮是否应该被禁用。返回值是一个新的Observable对象，值是由原始Observable对象的最新值组成的一个数组。
Angular combineLatest 操作符学习——保证在某些数据不为空的前提下进行下一步
最新发布
qq_44327851的博客
01-22 411
然后，我们使用 RxJS 中的 combineLatest 操作符将这两个 Observable 对象合并成为一个新的 Observable 对象，它会发出一个数组，数组中包含了 value1 和 value2 两个输入框的最新值。我们使用 subscribe 方法订阅上述合并后的 Observable 对象，当订阅到最新值数组时，我们判断其中的两个值是否都存在，如果存在，则在 runApiWithValues 方法中调用需要执行的 API。当任何一个源 Observable 发出新值时，
RACSignal的combineLatest和merge（类似信号量机制）
weixin_46926959的博客
12-23 1835
RACSignal的combineLatest和merge
RxJava组合操作符
BoBoMEe
05-01 2521
概述RxJava 中的组合函数可以同时处理多个Observables来创建我们想要的Observable。组合操作符包含如下几种Mergemerge()将2-9个Observables合并到一个Observable中进行发射。 Merge可能会让合并的Observables发射的数据交错（如果想要没有交错，可以使用concat操作符）。 任何一个Observable发出onError的时候，on
Rxjava调用顺序的流程笔记
m0_54010212的博客
09-21 683
rxjava
undetected-chromedriver使用详解
06-06
undetected-chromedriver是一个Python库，它是基于Selenium WebDriver和ChromeDriver的封装，旨在提供更好的自动化测试和爬虫体验。...这就是undetected-chromedriver的使用详解，希望对你有帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值