RxJava进阶四（组合类操作符）

最新推荐文章于 2018-11-09 22:53:17 发布
最新推荐文章于 2018-11-09 22:53:17 发布
阅读量1.5k 收藏 2
点赞数 7
分类专栏： 【 Android 】 【 Java 】 文章标签： rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/walid1992/article/details/52759728
版权

RxJava进阶一（创建类操作符）
RxJava进阶二（转换类操作符）
RxJava进阶三（过滤类操作符）
RxJava进阶四（组合类操作符）

前言

本篇文章带着大家熟悉一下RxJava的组合类操作符，本系列文章仅是带大家认识一下这些操作符的用法，并没有对操作符进行多种形态的使用，具体的还需要大家在使用时注意~

操作符总览

CombineLatest、Join、Merge、StartWith、Switch、Zip…

具体使用介绍

CombineLatest

当两个Observables中的任何一个发射了一个数据时，将两个Observables数据通过指定的规则进行处理，将结果进行发射~

代码示例：

        Observable<Long> observable1 = Observable.interval(0, 500, TimeUnit.MILLISECONDS).take(3);
        Observable<Long> observable2 = Observable.interval(500, 500, TimeUnit.MILLISECONDS).take(3);

        Observable.combineLatest(observable1, observable2, new Func2<Long, Long, Long>() {
            @Override
            public Long call(Long along1, Long along2) {
                System.out.println("along1 --> " + along1);
                System.out.println("along2 --> " + along2);
                return along1 + along2;
            }
        }).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                System.out.println("result = " + aLong);
                System.out.println("--------------");
            }
        });

运行结果：

10-08 17:00:12.319 6650-6698/com.shenghan.haobaobei I/System.out: along1 --> 1
10-08 17:00:12.319 6650-6698/com.shenghan.haobaobei I/System.out: along2 --> 0
10-08 17:00:12.319 6650-6698/com.shenghan.haobaobei I/System.out: result = 1
10-08 17:00:12.319 6650-6698/com.shenghan.haobaobei I/System.out: --------------
10-08 17:00:12.816 6650-6728/com.shenghan.haobaobei I/System.out: along1 --> 2
10-08 17:00:12.816 6650-6728/com.shenghan.haobaobei I/System.out: along2 --> 0
10-08 17:00:12.816 6650-6728/com.shenghan.haobaobei I/System.out: result = 2
10-08 17:00:12.817 6650-6728/com.shenghan.haobaobei I/System.out: --------------
10-08 17:00:12.818 6650-6698/com.shenghan.haobaobei I/System.out: along1 --> 2
10-08 17:00:12.820 6650-6698/com.shenghan.haobaobei I/System.out: along2 --> 1
10-08 17:00:12.821 6650-6698/com.shenghan.haobaobei I/System.out: result = 3
10-08 17:00:12.821 6650-6698/com.shenghan.haobaobei I/System.out: --------------
10-08 17:00:13.315 6650-6698/com.shenghan.haobaobei I/System.out: along1 --> 2
10-08 17:00:13.315 6650-6698/com.shenghan.haobaobei I/System.out: along2 --> 2
10-08 17:00:13.315 6650-6698/com.shenghan.haobaobei I/System.out: result = 4
10-08 17:00:13.315 6650-6698/com.shenghan.haobaobei I/System.out: --------------

结论：

* 1.只有当两个observable都发射过第一项数据时，才能进行组合发射*

从log日志来看，observable1打印的第一项数据为1，所以可以推断observable1发射的0数据时，observable2并没有发射过数据，所以并没有进行组合。

* 2.当observable1与observable2都发射首个数据后，在此发射任何数据都会找相应的另外一个observable的最新数据进行组合发射*

Join

无论何时，如果一个Observable发射了一个数据项，只要在另一个Observable发射的数据项定义的时间窗口内，就将两个Observable发射的数据合并发射~

        Observable<Long> observable1 = Observable.interval(2000, 1000, TimeUnit.MILLISECONDS).take(3);
        Observable<Long> observable2 = Observable.interval(2500, 1000, TimeUnit.MILLISECONDS).take(3);

        observable1
                .join(
                        observable2,
                        new Func1<Long, Observable<Long>>() {
                            @Override
                            public Observable<Long> call(Long aLong) {
                                //使Observable延迟500毫秒执行
                                System.out.println("observable1 -- >" + aLong);
                                return Observable.just(aLong).delay(500, TimeUnit.MILLISECONDS);
                            }
                        },
                        new Func1<Long, Observable<Long>>() {
                            @Override
                            public Observable<Long> call(Long aLong) {
                                System.out.println("observable2 -- >" + aLong);
                                return Observable.just(aLong).delay(500, TimeUnit.MILLISECONDS);
                            }
                        },
                        new Func2<Long, Long, Long>() {
                            @Override
                            public Long call(Long aLong1, Long aLong2) {
                                System.out.println("aLong1 = " + aLong1);
                                System.out.println("aLong2 = " + aLong2);
                                return aLong1 + aLong2;
                            }
                        })
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        System.out.println("result = " + aLong);
                        System.out.println("--------------");
                    }
                });

运行结果：

10-08 16:47:56.988 20959-21011/com.shenghan.haobaobei I/System.out: observable1 -- >0
10-08 16:47:57.488 20959-21041/com.shenghan.haobaobei I/System.out: observable2 -- >0
10-08 16:47:57.488 20959-21041/com.shenghan.haobaobei I/System.out: aLong1 = 0
10-08 16:47:57.488 20959-21041/com.shenghan.haobaobei I/System.out: aLong2 = 0
10-08 16:47:57.488 20959-21041/com.shenghan.haobaobei I/System.out: result = 0
10-08 16:47:57.488 20959-21041/com.shenghan.haobaobei I/System.out: --------------
10-08 16:47:57.991 20959-21011/com.shenghan.haobaobei I/System.out: observable1 -- >1
10-08 16:47:57.991 20959-21011/com.shenghan.haobaobei I/System.out: aLong1 = 1
10-08 16:47:57.991 20959-21011/com.shenghan.haobaobei I/System.out: aLong2 = 0
10-08 16:47:57.991 20959-21011/com.shenghan.haobaobei I/System.out: result = 1
10-08 16:47:57.991 20959-21011/com.shenghan.haobaobei I/System.out: --------------
10-08 16:47:58.490 20959-21041/com.shenghan.haobaobei I/System.out: observable2 -- >1
10-08 16:47:58.490 20959-21041/com.shenghan.haobaobei I/System.out: aLong1 = 1
10-08 16:47:58.490 20959-21041/com.shenghan.haobaobei I/System.out: aLong2 = 1
10-08 16:47:58.490 20959-21041/com.shenghan.haobaobei I/System.out: result = 2
10-08 16:47:58.490 20959-21041/com.shenghan.haobaobei I/System.out: --------------
10-08 16:47:58.990 20959-21011/com.shenghan.haobaobei I/System.out: observable1 -- >2
10-08 16:47:58.990 20959-21011/com.shenghan.haobaobei I/System.out: aLong1 = 2
10-08 16:47:58.990 20959-21011/com.shenghan.haobaobei I/System.out: aLong2 = 1
10-08 16:47:58.990 20959-21011/com.shenghan.haobaobei I/System.out: result = 3
10-08 16:47:58.990 20959-21011/com.shenghan.haobaobei I/System.out: --------------
10-08 16:47:59.489 20959-21041/com.shenghan.haobaobei I/System.out: observable2 -- >2
10-08 16:47:59.489 20959-21041/com.shenghan.haobaobei I/System.out: aLong1 = 2
10-08 16:47:59.489 20959-21041/com.shenghan.haobaobei I/System.out: aLong2 = 2
10-08 16:47:59.489 20959-21041/com.shenghan.haobaobei I/System.out: result = 4
10-08 16:47:59.489 20959-21041/com.shenghan.haobaobei I/System.out: --------------

结论：

* 1.只有当两个observable都发射过第一项数据时，才能进行组合发射*

从log日志来看，observable1发射数据0时，组合的call方法并没有被执行，而当observable2发射数据0后，组合call方法被回调了。

* 2.当observable1与observable2都发射首个数据后，在此发射任何数据都会找相应的另外一个observable的最新数据进行组合发射*

Merge

将两个Observable发射的数据按照时间顺序进行组合，合并成一个Observable进行发射~

代码示例：

        Observable<String> observable1 = Observable.interval(0, 500, TimeUnit.MILLISECONDS).take(3).flatMap(new Func1<Long, Observable<String>>() {
            @Override
            public Observable<String> call(Long aLong) {
                return Observable.just("observable1 -- >" + aLong);
            }
        });
        Observable<String> observable2 = Observable.interval(500, 500, TimeUnit.MILLISECONDS).take(3).flatMap(new Func1<Long, Observable<String>>() {
            @Override
            public Observable<String> call(Long aLong) {
                return Observable.just("observable2 -- >" + aLong);
            }
        });

        Observable
                .merge(observable1, observable2)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String aString) {
                        System.out.println("result = " + aString);
                    }
                });

运行结果：

10-08 17:11:33.696 16661-16737/com.shenghan.haobaobei I/System.out: result = observable1 -- >0
10-08 17:11:34.194 16661-16737/com.shenghan.haobaobei I/System.out: result = observable1 -- >1
10-08 17:11:34.198 16661-16711/com.shenghan.haobaobei I/System.out: result = observable2 -- >0
10-08 17:11:34.695 16661-16737/com.shenghan.haobaobei I/System.out: result = observable1 -- >2
10-08 17:11:34.698 16661-16711/com.shenghan.haobaobei I/System.out: result = observable2 -- >1
10-08 17:11:35.196 16661-16711/com.shenghan.haobaobei I/System.out: result = observable2 -- >2
StartWith

在源Observable发射数据之前，先发射一个指定的数据序列或数据项~

代码示例：

        Observable
                .just(4, 5, 6)
                .startWith(1, 2, 3)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("result = " + integer);
                    }
                });

运行结果：

10-08 17:16:43.077 21830-21830/com.shenghan.haobaobei I/System.out: result = 1
10-08 17:16:43.078 21830-21830/com.shenghan.haobaobei I/System.out: result = 2
10-08 17:16:43.078 21830-21830/com.shenghan.haobaobei I/System.out: result = 3
10-08 17:16:43.078 21830-21830/com.shenghan.haobaobei I/System.out: result = 4
10-08 17:16:43.078 21830-21830/com.shenghan.haobaobei I/System.out: result = 5
10-08 17:16:43.078 21830-21830/com.shenghan.haobaobei I/System.out: result = 6
switchOnNext

把一组Observable转换成一个Observable，如果在同一个时间内产生两个或多个Observable产生的数据，只发射最后一个Observable产生的数据~

示例代码：

        Observable<Observable<String>> observable = Observable.interval(2000, 500, TimeUnit.MILLISECONDS).map(new Func1<Long, Observable<String>>() {
            @Override
            public Observable<String> call(Long aLongOutside) {
                //每隔250毫秒产生一组数据（0,1,2,3,4)
                return Observable.interval(0, 250, TimeUnit.MILLISECONDS).map(new Func1<Long, String>() {
                    @Override
                    public String call(Long aLongInside) {
                        return "aLongOutside = " + aLongOutside + "| aLongInside = " + aLongInside;
                    }
                }).take(5);
            }
        }).take(2);

        Observable.switchOnNext(observable).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                System.out.println("result = " + s);
            }
        });

运行结果：

10-08 18:20:14.605 2921-2993/com.shenghan.haobaobei I/System.out: result = aLongOutside = 0| aLongInside = 0
10-08 18:20:14.857 2921-2993/com.shenghan.haobaobei I/System.out: result = aLongOutside = 0| aLongInside = 1
10-08 18:20:15.103 2921-3055/com.shenghan.haobaobei I/System.out: result = aLongOutside = 1| aLongInside = 0
10-08 18:20:15.353 2921-3055/com.shenghan.haobaobei I/System.out: result = aLongOutside = 1| aLongInside = 1
10-08 18:20:15.604 2921-3055/com.shenghan.haobaobei I/System.out: result = aLongOutside = 1| aLongInside = 2
10-08 18:20:15.853 2921-3055/com.shenghan.haobaobei I/System.out: result = aLongOutside = 1| aLongInside = 3
10-08 18:20:16.104 2921-3055/com.shenghan.haobaobei I/System.out: result = aLongOutside = 1| aLongInside = 4
Zip

使用一个指定的函数将多个Observable发射的数据组合在一起，然后将这个函数的结果作为单项数据发射，严格周期顺序进行合并，不能单独发射~

示例代码：

        Observable<String> observable1 = Observable.just("walid - 1", "walid - 2", "walid - 3");
        Observable<String> observable2 = Observable.just("Jordan - 1", "Jordan - 2", "Jordan - 3", "Jordan - 4");
        Observable.zip(observable1, observable2, new Func2<String, String, String>() {
            @Override
            public String call(String s1, String s2) {
                return s1 + " | " + s2;
            }
        }).subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("onError");
            }

            @Override
            public void onNext(String value) {
                System.out.println("onNext --> " + value);
            }
        });

运行结果：

10-08 18:53:31.772 24793-24793/com.shenghan.haobaobei I/System.out: onNext --> walid - 1 | Jordan - 1
10-08 18:53:31.772 24793-24793/com.shenghan.haobaobei I/System.out: onNext --> walid - 2 | Jordan - 2
10-08 18:53:31.772 24793-24793/com.shenghan.haobaobei I/System.out: onNext --> walid - 3 | Jordan - 3
10-08 18:53:31.772 24793-24793/com.shenghan.haobaobei I/System.out: onCompleted

结论：

* 1.只有每个observable都依次产品一轮数据时，才会统一发射一次，当不会有完整一轮数据时，视为完成*

从log日志来看，observable1产生的数据是与observable2一一对应的，也就是只有observable1与observable2同时产生数据时才会统一发射一次~

* 2.当不满足所有observable都有数据可产品时，视为完成状态*

从log日志来看，observable2最后一项数据“Jordan - 4”并没有打印，原因是observable1并没有数据可以产生了，所以不满足发射条件，视为完成状态~

结语

组合类操作符，就简单介绍到这里，希望能够对同学有所帮助，谢谢~

王永迪
关注
专栏目录
RxJava 操作符 图片
03-31
在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成部分，它们提供了丰富的功能来创建、转换、过滤和组合数据流。 首先，我们来了解一下什么是操作符。在 RxJava 中，操作符是用于...
Android 轮询实现的三种方式
snow_lyGirl
08-23 9901
1.通过rxjava实现(代码中使用了Lambda表达式) private static final int PERIOD = 10 * 1000; private static final int DELAY = 100; private Disposable mDisposable; /** * 定时循环任务 */ private void timeLoop() { mDisp...
自动重置事件对象与人工重置事件对象
心之所向，身之所往
05-17 1647
1、自动重置事件对象。 #include #include using namespace std; DWORD WINAPI Fun1Proc(LPVOID lpParameter); DWORD WINAPI Fun2Proc(LPVOID lpParameter); DWORD WINAPI Fun3Proc(LPVOID lpParameter); HANDL
Carson带你学Android：RxJava组合/合并操作符
Carson带你学Android
11-06 1万+
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的 组合 / 合并操作符，并
CreateEvent，OpenEvent成功后 是否需要::CloseHandle(xxx); 避免句柄泄漏
weixin_34335458的博客
01-29 618
bool bExist = false; HANDLE hHandle = ::CreateEvent(NULL, FALSE, FALSE, L"Global\\xxxxx_name"); if (hHandle && ERROR_ALREADY_EXISTS == GetLastError()) { bExist = true; ...
初识RxJava（四）组合类 操作符
weixin_33692284的博客
11-09 143
前言： 前面已经记录了 三种操作符，下面开始第四种操作符的相关使用笔记，每天学一点没什么坏处，而且现在 RxJava 并不是什么新鲜玩意，都到现在了，还不知道 RxJava 怎么使用，那么 笔者请你 打开 Boss直聘 app 看看 Android 的招聘信息，你就知道是什么了。不墨迹了，开始写笔记。 正文： 1、zip 操作符 1)、作用 将多个 被观...
Rxjava2操作符大全
04-24
RxJava2的操作符是其核心特性之一，它们允许开发者对数据流进行各种操作和转换。以下为RxJava2中一些常用操作符的详细说明： ### 创建操作符 这些操作符用于创建Observable对象，为数据流提供起点。 - **just()**...
RxJava2.0在android开发中的实用操作符总结
04-14
本文将深入探讨RxJava2.0的一些实用操作符，帮助开发者更好地理解和运用这个强大的工具。 1. **创建Observable** - `just()`: 用于从单个或多个值创建Observable。 - `fromArray()`: 将数组转换为Observable，...
php 操作符与控制结构
10-28
操作符大致可以分为以下几类： 1. **算术操作符**：执行基本的数学运算，如加法(+), 减法(-), 乘法(*), 除法(/) 和取余(%). 2. **复合赋值操作符**：同时进行赋值和操作，例如 `$a += $b` 相当于 `$a = $a + $b`. ...
你用不惯 RxJava，只因缺了这把钥匙(推荐)
08-26
通过组合这些操作符，我们可以构建出复杂的数据处理逻辑，而无需手动管理线程或回调。 为了更好地理解并掌握 RxJava 操作符，你可以参考开源的全套操作符示例代码，这将有助于你通过实践来感知每个操作符的功能。在...
Weex Android SDK源码分析之界面渲染（上）
热门推荐
王永迪的专栏
06-18 2万+
首先感谢阿里巴巴团队对移动端跨三端与动态化做出的杰出贡献，阿里在6月初，彻底开放了weex android与ios端内测，最近已使用一周有余，效果果然达到了learn once，write everywhere！而且运行效果可以与原声媲美，并且virtual dom的加入更加优化了性能问题，切对native扩展等提供了很好的预留，目前可以采用组件形式与全页形式进行集成，接下来我给大家介绍下weex在android端的工作原理及代码分析。
Weex Android SDK源码分析之Module（modal）
王永迪的专栏
06-18 1万+
前言 当您来阅读这篇文章时，代表您已经是weex粉丝了，我说的对吗？(-_-) 可是您只会使用可不行，本篇博文介绍Weex Moudle中的model 使用与源码分析。
Android原理揭秘之APk生成过程
王永迪的专栏
06-07 1万+
apk这个字眼大家肯定在清楚不过了，可是好多的程序员确仅仅知道使用或者说知道这个的表面含义，但是我们不能只会吃面包，确不去了解面包是如何生产出来的，我还是建议大家还是多多了解下apk的生成过程以及apk、dex、jar、class、R文件，这些个貌似简单却都有些深意的名词~
Android 发布开源项目到jcenter
王永迪的专栏
06-03 1万+
相信现在android程序猿们大多都使用了studio进行开发，想必大家对于compile 'com.android.support:appcompat-v7:23.3.0'这种方式引入开源项目肯定不陌生，那么大家有没有自己发布开源项目让别人来引用的想法呢？猜也猜得到，大家都想，那么下面我与大家分享一下自己的上传方法，很是简单哦~
Android自动获取短信验证码
王永迪的专栏
06-18 1万+
自动获取验证码
Weex Android SDK源码分析之Module（navigator）
王永迪的专栏
06-18 1万+
之前已经介绍了module中的model，本篇博文介绍Weex Moudle中的navigator使用与源码分析。
Android重启app功能实现
王永迪的专栏
06-03 1万+
今天在做一个热修复的功能，发现有时需要重启app后修复代码才能生效，所以简单调查了下重启的方案，进而分享给大家~
Weex Android SDK源码分析之界面渲染（下）
王永迪的专栏
06-25 6171
前言在你读本篇文章之前请确认您已经阅读 Weex Android SDK源码分析之界面渲染（上），否则建议您想阅读上篇文章有利于您更深刻的了解~
Android最新控件FlexboxLayout
王永迪的专栏
05-31 5880
最近Google开源了一个项目叫「FlexboxLayout」，但是貌似没多少资料对这个项目介绍的，那么今天来讲讲这个项目的作用以及简单的使用介绍。1什么是 Flexbox简单来说 Flexbox 是属于web前端领域CSS的一种布局方案，是2009年W3C提出了一种新的布局方案，可以简便、完整、响应式地实现各种页面布局，并且 React Native 也是使用的 Flex 布局。你可以简单的
Java RxJava库操作符实战与示例
Java的RxJava库操作符是其强大功能的核心组件，它在Android开发中的应用主要体现在异步处理和事件驱动编程上。RxJava通过一系列操作符提供了一种简洁的方式来处理数据流，使得代码更为易读和维护。本篇文章将深入...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值