类型 对象后回来,操作符前

前言

  • Rxjava,由于其依靠事件流的链式调用、逻辑简洁 &
    使用轻松
    的性状,异常受各大 Android开辟者的欢迎。

Github截图

若果还不断解 RxJava,请看作品:Android:那是一篇 清晰 &
易懂的福睿斯xjava 入门教程

  • RxJava这么受接待的原委,在于其提供了增进 &
    功用强大的操作符,大概能不辱职务具备的作用需要
  • 明天,我将为大家详细介绍RxJava操作符中最常用的改变操作符,并附带
    Retrofit 结合 RxJava的实例Demo教学,希望您们会欣赏。
  1. 本连串文章首要依据 Rxjava 2.0
  2. 接下去的年月,本身将不止推出 AndroidRxjava 2.0
    的一五种文章,包蕴原理、操作符、应用场景、背压等等

    ,风乐趣能够一而再关心Carson_Ho的安卓开拓笔记!!

示意图


图片 1

目录

示意图


  • Rxjava,由于其传说事件流的链式调用、逻辑简洁 &
    使用轻巧
    的性状,相当受各大 Android开荒者的应接。

1. 作用

  • 对事件种类中的事件 / 整个事件系列实行加工管理(即变换),使得其调换成分歧的轩然大波 / 整个事件体系
  • 切切实实原理如下

示意图


图片 2Github截图

2. 类型

  • RxJava中常见的转移操作符如下:

    示意图

  • 下边,笔者将对每一个操作符进行详细介绍

注:本文只解说RxJava2在付出进度中常用的转变操作符


借使还连连解安德拉xJava,请看文章:Android:这是壹篇 清晰 & 易懂的宝马X5xjava
入门教程

3. 应用场景 & 对应操作符 介绍

  • 下面,我将对 RxJava2 中的调换操作符实行逐项批注
  • 注:在使用RxJava 2操作符前,记得在项目标Gradle中增添正视:

dependencies {
      compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
      compile 'io.reactivex.rxjava2:rxjava:2.0.7'
      // 注:RxJava2 与 RxJava1 不能共存,即依赖不能同时存在
}
  • RxJava那样受接待的原委,在于其提供了丰盛 &
    功效庞大的操作符,差不多能成功具备的职能须要
  • 今天,作者将为我们献上壹份
    RxJava操作符的详尽使用计策,希望你们会喜欢。

3.1 Map()

  • 作用
    对 被观望者发送的每二个事件都经过 点名的函数
    管理,从而转变成别的1种事件

即, 将被观察者发送的轩然大波转变为随机的档期的顺序事件。

  • 原理

示意图

  • 动用场景
    数据类型调换

  • 切实接纳
    上面以将 使用Map() 将事件的参数从 整型 变换成 字符串类型
    为例子表达

示意图

 // 采用RxJava基于事件流的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {

            // 1. 被观察者发送事件 = 参数为整型 = 1、2、3
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);

            }
            // 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换:整型变换成字符串类型
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "使用 Map变换操作符 将事件" + integer +"的参数从 整型"+integer + " 变换成 字符串类型" + integer ;
            }
        }).subscribe(new Consumer<String>() {

            // 3. 观察者接收事件时,是接收到变换后的事件 = 字符串类型
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
  • 测试结果

示意图

从地点可以看看,map() 将参数中的 Integer 类型对象调换来贰个
String类型 对象后赶回

同时,事件的参数类型也由 Integer 类型形成了 String 类型


  1. 本系列小说主要依靠 Rxjava 2.0
  2. 接下去的年华,自个儿将持续生产 AndroidRxjava 2.0
    的一文山会海小说,包含原理、操作符、应用场景、背压等等

    ,风乐趣能够承接关注Carson_Ho的安卓开采笔记!!

3.2 FlatMap()

  • 作用:将被观望者发送的风云体系进行 拆分 &
    单独调换
    ,再统10%叁个新的轩然大波连串,最终再张开荒送

  • 原理

  1. 为事件体系中各样事件都创制一个 Observable 对象;
  2. 将对每种 原始事件 调换后的 新事件 都放入到对应 Observable对象;
  3. 将新建的各样Observable 都合并到一个 新建的、总的Observable
    对象;
  4. 新建的、总的Observable 对象 将 新合并的事件连串发送给观望者(Observer

示意图

  • 使用场景
    冬辰的将被观看者发送的满贯事件连串实行转移

  • 切实选取

// 采用RxJava基于事件流的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 采用flatMap()变换操作符
        }).flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                    // 通过flatMap中将被观察者生产的事件序列先进行拆分,再将每个事件转换为一个新的发送三个String事件
                    // 最终合并,再发送给被观察者
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
  • 测试结果
示意图

注:新合并生成的轩然大波种类顺序是冬日的,即 与旧系列发送事件的顺序毫不相关

图片 3示意图

3.3 ConcatMap()

  • 作用:类似FlatMap()操作符

  • FlatMap()的 不一样在于:拆分 & 重新联合生成的轩然大波连串 的依次 =
    被观望者旧系列生产的依次

  • 原理

示意图

  • 利用场景
    以不改变应万变的将被观望者发送的万事事件序列进行转移

  • 实际使用

// 采用RxJava基于事件流的链式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 采用concatMap()变换操作符
        }).concatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                    // 通过concatMap中将被观察者生产的事件序列先进行拆分,再将每个事件转换为一个新的发送三个String事件
                    // 最终合并,再发送给被观察者
                }
                return Observable.fromIterable(list);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d(TAG, s);
            }
        });
  • 测试结果
示意图

注:新合并生成的轩然大波体系顺序是铁板钉钉的,即 严谨依据旧类别发送事件的逐一


本文全部代码 Demo均存放在Carson_Ho的Github地址

3.4 Buffer()

  • 作用
    定时从 被阅览者(Obervable)需求发送的轩然大波中 获取一定数额的事件 &
    放到缓存区中,最后发送

  • 原理

示意图

  • 选拔场景
    缓存被观察者发送的轩然大波

  • 实际使用
    那么,Buffer()老是是收获多少个事件放到缓存区中的呢?下边作者将由此二个例子来证明

// 被观察者 需要发送5个数字
        Observable.just(1, 2, 3, 4, 5)
                .buffer(3, 1) // 设置缓存区大小 & 步长
                                    // 缓存区大小 = 每次从被观察者中获取的事件数量
                                    // 步长 = 每次获取新事件的数量
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }
                    @Override
                    public void onNext(List<Integer> stringList) {
                        //
                        Log.d(TAG, " 缓存区里的事件数量 = " +  stringList.size());
                        for (Integer value : stringList) {
                            Log.d(TAG, " 事件 = " + value);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应" );
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });
  • 测试结果

示意图

  • 进程解释

下边,小编将经过贰个图来分解Buffer()原理 & 整个例子的结果

示意图

至此,关于RxJava2中任重先生而道远的转换操作符已经疏解结束


图片 4示意图

4. 实在付出须求案例

  • 调换操作符的重大开辟供给场景 = 嵌套回调(Callback hell
  • 下面,作者将选用3个实际应用场景实例来讲学嵌套回调(Callback hell

切切实实请看小说Android 普拉多xJava
实际使用案例教学:网络请求嵌套回调


RxJava 操作符的有血有肉简单介绍如下:

5. Demo地址

上述全体的Demo源代码都存放在:Carson_Ho的Github地址:RxJava2_更动操作符

爱抚的麻烦点个star


图片 5示意图

6. 总结

  • 下边,小编将用一张图总结 RxJava2 中常用的转移操作符

示意图

  • 接下去的时日,自己将四处推出 AndroidRxjava 2.0
    的1雨后玉兰片小说,包括原理、操作符、应用场景、背压等等

    ,风乐趣能够继续关切Carson_Ho的安卓开辟笔记!!

示意图


  • RxJava作用庞大,所以其对应的操作符的门类也越多
  • 遵照功效成效的不等,智跑xJava的操作符分类如下:

请点赞!因为你的砥砺是自身创作的最大重力!

连带文章阅读


图片 6示意图

接待关怀Carson_Ho的简书!

不按时分享关于安卓开垦的干货,追求短、平、快,但却不缺深度

  • 上边,笔者将对每类的操作符举行详细疏解

注:在使用RxJava 2操作符前,记得在类型的Gradle中增多依赖:

dependencies { compile 'io.reactivex.rxjava2:rxandroid:2.0.1' compile 'io.reactivex.rxjava2:rxjava:2.0.7' // 注:RxJava2 与 RxJava1 不能共存,即依赖不能同时存在}

3.一 创设操作符

  • 职能创建 被阅览者( Observable) 对象 & 发送事件。

  • 行使场景

图片 7示意图

  • 品类依照上述应用场景,创立操作符的品类包罗:

图片 8示意图

  • 具体操作符 & 应用场景 详细介绍Android BMWX3xJava:最基础的操作符详解 –
    成立操作符

  • 事实上付出须要案例下边,作者将执教成立操作符的一个科学普及实际需要案例:网络请求轮询

  1. 该例子将整合RetrofitRxJava 进行批注
  2. 切切实实请看文章:Android KoleosxJava 实际行使疏解:网络请求轮询

三.二 调换操作符

  • 意义对事件类别中的事件 / 整个事件类别进行加工管理,使得其调换成分化的轩然大波 / 整个事件种类
  • 现实原理

图片 9示意图

  • 运用场景嵌套回调(Callback hell

  • 类型依照上述应用场景,常见的转移操作符类型包含:

    图片 10示意图

  • 具体操作符 & 应用场景 详细介绍Android 昂科拉xJava:图像和文字详解 转变操作符

  • 实际上付出必要案例下边,作者将执教调换操作符的贰个科学普及实际须要案例:互联网请求嵌套回调

  1. 该例子将构成RetrofitRxJava 实行疏解
  2. 切切实实请看小说:Android 汉兰达xJava 实际行使疏解:网络请求嵌套回调

三.三 组合 / 合并操作符

  • 意义组合 三个被旁观者(Observable) & 合并供给发送的事件

  • 行使场景

    1. 结合多少个被观望者
    2. 合并四个事件
    3. 出殡事件前扩张发送事件
    4. 计算算与发放送事件数量
  • 花色依据上述应用场景,常见的构成 / 合并操作符 首要有:

    图片 11示意图

  • 具体操作符 & 应用场景 详细介绍Android 牧马人xJava:组合 / 合并操作符
    详细教程

  • 骨子里支付需求案例上边,小编将执教组合操作符的宽广实际需要案例

该例子将构成RetrofitRxJava 进行教学

  1. Android 哈弗xJava 实际应用讲授:合并数据源
  2. Android ENCORExJava 实际运用讲授:从磁盘 / 内部存款和储蓄器缓存中 获取缓存数据
  3. Android 路虎极光xJava 实际应用批注:联合判别

叁.肆 功用性操作符

  • 功效扶助被阅览者(Observable) 在发送事件时落到实处部分成效性须要

  • 实际选用场景

  1. 再而三 观望者 & 被观察者
  2. 线程调度
  3. 错误管理
  4. 事件生命周期操作
  5. 延时操作
  6. 再一次发送操作
  • 类型遵照上述应用场景,常见的成效性操作符 重要有:

    图片 12示意图

  • 具体操作符 & 应用场景 详细介绍Android WranglerxJava:功效性操作符 周详授课

  • 实质上费用须要案例下边,笔者将教授组合操作符的科学普及实际须要案例

该例子将构成RetrofitRxJava 举行讲明

  1. Android GL450xJava:细说 线程序调节制(含Retrofit实例讲明)
  2. Android 普拉多xJava 实际应用讲明:互联网请求出错重连(结合Retrofit)
  3. Android QX56xJava 实际运用讲授:互联网请求轮询(结合Retrofit)

三.5 过滤操作符

  • 效果过滤 / 筛选 被观望者(Observable)发送的轩然大波 & 观望者
    Observer)接收的风云

  • 运用场景

    1. 基于 钦点条件 过滤事件
    2. 依照 钦赐事件数量 过滤事件
    3. 基于 内定时期 过滤事件
    4. 依据 钦赐事件地点 过滤事件
  • 品类依据上述应用场景,常见的过滤操作符 首要有:

    图片 13示意图

  • 具体操作符 & 应用场景 详细介绍Android 帕杰罗xJava:过滤操作符 周到授课

  • 实质上支付须要案例上面,作者将教师组合操作符的普及实际供给案例

该例子将构成RetrofitRxJava 实行教学

  1. Android 科雷傲xJava 实际利用批注:作用防抖
  2. Android HavalxJava 实际行使解说:联想寻找优化

叁.六 条件 / 布尔操作符

  • 职能通过设置函数,判别被观望者(Observable)发送的事件是不是符合条件

  • 类型RxJava2中,条件 / 布尔操作符的档案的次序包涵:

图片 14示意图

  • 具体操作符详解Android 卡宴xJava:详解 条件 / 布尔操作符

至此,关于RxJava 2 中的操作符解说结束。

  • 本文首要对 RxJava2
    中常用的富有类型操作符实行了详细介绍,上面用壹张图实行总括

图片 15示意图

  • 接下去的时日,自家将持续生产 AndroidRxjava 2.0
    的1多种文章,蕴含原理、操作符、应用场景、背压等等

    ,有意思味能够承接关注Carson_Ho的安卓开拓笔记!!

图片 16示意图

相关作品阅读

  • 操作符使用Android:那是1篇 清晰 & 易懂的汉兰达xjava 入门教程Android
    RubiconxJava:最基础的操作符详解 – 创设操作符Android 福特ExplorerxJava:图像和文字详解
    调换操作符Android OdysseyxJava:组合 / 合并操作符 详细教程Android
    凯雷德xJava:成效性操作符 周密解说Android 奥迪Q7xJava:过滤操作符
    周密疏解Android PRADOxJava:详解 条件 / 布尔操作符
  • 其实使用讲授Android HummerH二xJava 实际应用讲授:网络请求轮询Android
    OdysseyxJava 实际应用讲明:互联网请求轮询Android 宝马X伍xJava
    实际利用批注:互连网请求嵌套回调Android CRUISERxJava
    实际采取批注:合并数据源Android 福睿斯xJava 实际运用疏解:从磁盘 /
    内部存款和储蓄器缓存中 获取缓存数据Android 汉兰达xJava
    实际行使疏解:联合推断Android 库罗德xJava:细说
    线程序调节制(含Retrofit实例讲明)Android 景逸SUVxJava
    实际使用疏解:网络请求出错重连(结合Retrofit)Android 奔驰G级xJava
    实际利用批注:互联网请求轮询(结合Retrofit)Android 昂CoraxJava
    实际选拔解说:功用防抖Android 逍客xJava 实际采用批注:联想寻找优化
  • 外加首要知识Android :周到解析QX56xJava 背压战略Android 奔驰G级xJava:贰.0
    相对于 壹.0的翻新 & 变化(含 猎豹CS陆xJava
    1.0的翻新使用)Android:Retrofit 结合 奥德赛xJava的幽雅使用

欢迎关怀Carson_Ho的简书!

不按时分享有关安卓开拓的干货,追求短、平、快,但却不缺深度

图片 17

相关文章