RxJava操作符详解-创建操作符

最新推荐文章于 2023-10-15 17:24:48 发布
最新推荐文章于 2023-10-15 17:24:48 发布
阅读量264 收藏
点赞数
分类专栏： RxJava 文章标签： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huahuahua333686/article/details/78999651
版权


1. 作用

创建 被观察者（ Observable） 对象 & 发送事件。

2. 类型

  • 创建操作符分类
基本创建： create()
快速创建&发送事件： just()、formArray()、fromIterable()、never()、empty()、error()
延迟创建： defer()、timer()、interval()、intervalRange()、range()、rangeLong

3. 应用场景及详细介绍

注：在使用RxJava 2操作符前，记得在项目的Gradle中添加依赖：

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

3.1 基本创建

  • 需求场景
    完整的创建被观察者对象

  • 对应操作符类型

create（）

  • 作用
    完整创建1个被观察者对象（Observable）RxJava 中创建被观察者对象最基本的操作符
  • 具体使用
/ **
   * 1. 通过creat（）创建被观察者 Observable 对象
   */ 
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
          // 传入参数： OnSubscribe 对象
          // 当 Observable 被订阅时，OnSubscribe 的 call() 方法会自动被调用，即事件序列就会依照设定依次被触发
          // 即观察者会依次调用对应事件的复写方法从而响应事件
          // 从而实现由被观察者向观察者的事件传递 & 被观察者调用了观察者的回调方法 ，即观察者模式
/ **
   * 2. 在复写的subscribe（）里定义需要发送的事件
   */ 
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 通过 ObservableEmitter类对象 产生 & 发送事件
                // ObservableEmitter类介绍
                    // a. 定义：事件发射器
                    // b. 作用：定义需要发送的事件 & 向观察者发送事件
                   // 注：建议发送事件前检查观察者的isUnsubscribed状态，以便在没有观察者时，让Observable停止发射数据
                    if (!observer.isUnsubscribed()) {
                           emitter.onNext(1);
                           emitter.onNext(2);
                           emitter.onNext(3);
                }
                emitter.onComplete();
            }
        });
在具体使用时，一般采用  链式调用  来创建 
// 1. 通过creat（）创建被观察者对象
        Observable.create(new ObservableOnSubscribe<Integer>() {

            // 2. 在复写的subscribe（）里定义需要发送的事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {

                    emitter.onNext(1);
                    emitter.onNext(2);
                    emitter.onNext(3);

                emitter.onComplete();
            }  // 至此，一个被观察者对象（Observable）就创建完毕
        }).subscribe(new Observer<Integer>() {
            // 3. 通过通过订阅（subscribe）连接观察者和被观察者
            // 4. 创建观察者 & 定义响应事件的行为
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }
            // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件"+ value  );
            }

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

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

        });
    }

3.2 快速创建 & 发送事件

  • 需求场景
    快速的创建被观察者对象

  • 对应操作符类型

just（）

  • 作用
    1. 快速创建1个被观察者对象（Observable）
    2. 发送事件的特点：直接发送 传入的事件 
  • 应用场景
    快速创建 被观察者对象（Observable） & 发送10个以下事件
  • 具体使用
// 1. 创建时传入整型1、2、3、4
        // 在创建后就会发送这些对象，相当于执行了onNext(1)、onNext(2)、onNext(3)、onNext(4)
        Observable.just(1, 2, 3,4)   
            // 至此，一个Observable对象创建完毕，以下步骤仅为展示一个完整demo，可以忽略
            // 2. 通过通过订阅（subscribe）连接观察者和被观察者
            // 3. 创建观察者 & 定义响应事件的行为
         .subscribe(new Observer<Integer>() {
            
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }
            // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件"+ value  );
            }

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

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

        });
    }

fromArray（）

  • 作用
    1. 快速创建1个被观察者对象（Observable）
    2. 发送事件的特点：直接发送 传入的数组数据 ，会将数组中的数据转换为Observable对象

  • 应用场景

    1. 快速创建 被观察者对象（Observable） & 发送10个以上事件（数组形式）
    2. 数组元素遍历

  • 具体使用
    // 1. 设置需要传入的数组
     Integer[] items = { 0, 1, 2, 3, 4 };

        // 2. 创建被观察者对象（Observable）时传入数组
        // 在创建后就会将该数组转换成Observable & 发送该对象中的所有数据
        Observable.fromArray(items) 
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到了事件"+ value  );
            }

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

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

        });
    }

// 注：
// 可发送10个以上参数
// 若直接传递一个list集合进去，否则会直接把list当做一个数据元素发送

/*
  * 数组遍历
  **/
        // 1. 设置需要传入的数组
        Integer[] items = { 0, 1, 2, 3, 4 };

        // 2. 创建被观察者对象（Observable）时传入数组
        // 在创建后就会将该数组转换成Observable & 发送该对象中的所有数据
        Observable.fromArray(items)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "数组遍历");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "数组中的元素 = "+ value  );
                    }

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "遍历结束");
                    }

                });

    fromIterable（）

    • 作用
      1. 快速创建1个被观察者对象（Observable）
      2. 发送事件的特点：直接发送 传入的集合List数据，会将数组中的数据转换为Observable对象

      • 应用场景

        1. 快速创建 被观察者对象（Observable） & 发送10个以上事件（集合形式）
        2. 集合元素遍历

      • 具体使用

      /*
 * 快速发送集合
 **/
// 1. 设置一个集合
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

// 2. 通过fromIterable()将集合中的对象 / 数据发送出去
        Observable.fromIterable(list)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

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

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


/*
 * 集合遍历
 **/
        // 1. 设置一个集合
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);

        // 2. 通过fromIterable()将集合中的对象 / 数据发送出去
        Observable.fromIterable(list)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "集合遍历");
                    }

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "集合中的数据元素 = "+ value  );
                    }

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "遍历结束");
                    }
                });


    3.3 延迟创建

    • 需求场景
      1. 定时操作：在经过了x秒后，需要自动执行y操作
      2. 周期性操作：每隔x秒后，需要自动执行y操作

    defer（）

    • 作用
      直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件
    • 具体使用
    <-- 1. 第1次对i赋值 ->>
        Integer i = 10;

        // 2. 通过defer 定义被观察者对象
        // 注：此时被观察者对象还没创建
        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(i);
            }
        });

        <-- 2. 第2次对i赋值 ->>
        i = 15;

        <-- 3. 观察者开始订阅 ->>
        // 注：此时，才会调用defer（）创建被观察者对象（Observable）
        observable.subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "接收到的整数是"+ value  );
            }

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

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

    注:因为是在订阅时才创建，所以i值会取第2次的赋值


    timer（）

    • 作用
      1. 快速创建1个被观察者对象（Observable）
      2. 发送事件的特点：延迟指定时间后，发送1个数值0（Long类型）

    本质 = 延迟指定时间后，调用一次 onNext(0)

    • 应用场景
      延迟指定事件，发送一个0，一般用于检测
    • 具体使用
    // 延迟2s后，发送一个long类型数值
        Observable.timer(2, TimeUnit.SECONDS) 
                  .subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long value) {
                Log.d(TAG, "接收到了事件"+ value  );
            }

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

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

        });

// 注：timer操作符默认运行在一个新线程上
// 也可自定义线程调度器（第3个参数）：timer(long,TimeUnit,Scheduler)


    interval（）

    • 作用
      1. 快速创建1个被观察者对象（Observable）
      2. 发送事件的特点：每隔指定时间 就发送 事件

    发送的事件序列 = 从0开始、无限递增1的的整数序列

    • 具体使用
    // 参数说明：
        // 参数1 = 第1次延迟时间；
        // 参数2 = 间隔时间数字；
        // 参数3 = 时间单位；
        Observable.interval(3,1,TimeUnit.SECONDS)
                // 该例子发送的事件序列特点：延迟3s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个）
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }
                    // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

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

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

                });

// 注：interval默认在computation调度器上执行
// 也可自定义指定线程调度器（第3个参数）：interval(long,TimeUnit,Scheduler)

    intervalRange（）

    • 作用
      1. 快速创建1个被观察者对象（Observable）
      2. 发送事件的特点：每隔指定时间 就发送 事件，可指定发送的数据的数量
      3. 发送的事件序列 = 从0开始、无限递增1的的整数序列。作用类似于interval（），但可指定发送的数据的数量
    • 具体使用
    // 参数说明：
        // 参数1 = 事件序列起始点；
        // 参数2 = 事件数量；
        // 参数3 = 第1次事件延迟发送时间；
        // 参数4 = 间隔时间数字；
        // 参数5 = 时间单位
        Observable.intervalRange(3,10,2, 1, TimeUnit.SECONDS)
                // 该例子发送的事件序列特点：
                // 1. 从3开始，一共发送10个事件；
                // 2. 第1次延迟2s发送，之后每隔2秒产生1个数字（从0开始递增1，无限个）
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }
                    // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

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

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

                });


range（）

  • 作用
    1. 快速创建1个被观察者对象（Observable）
    2. 发送事件的特点：连续发送 1个事件序列，可指定范围

a. 发送的事件序列 = 从0开始、无限递增1的的整数序列
b. 作用类似于intervalRange（），但区别在于：无延迟发送事件

  • 具体使用

// 参数说明：
        // 参数1 = 事件序列起始点；
        // 参数2 = 事件数量；
        // 注：若设置为负数，则会抛出异常
        Observable.range(3,10)
                // 该例子发送的事件序列特点：从3开始发送，每次发送事件递增1，一共发送10个事件
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }
                    // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(Integer value) {
                        Log.d(TAG, "接收到了事件"+ value  );
                    }

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

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

                });

rangeLong（）

  • 作用：类似于range（），区别在于该方法支持数据类型 = Long
  • 具体使用
    与range（）类似



huahuahua不完
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava 操作符篇 - 创建操作符
doris_d的专栏
09-27 254
Create 创建Observable。 Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable { try { for (int i=0; i<10; i++) {
RxJava操作符汇总
chuyouyinghe的专栏
02-07 5807
RxJava操作符包含的操作符类型有如下几种： 1、创建操作符 ：创建被观察者（Observable）对象&发送事件 转自：RxJava操作符汇总_zengke的博客-CSDN博客_rxjava操作符 https://blog.csdn.net/zengke1993/article/details/80388510 ...
RxJava操作符入门
肇秋贰拾捌的博客
05-16 936
【代码】RxJava操作符入门。
Rxjava3 全新详解及常用操作符
ezconn的博客
10-15 2423
RxJava 是一个基于 Java 的响应式编程库，用于处理异步事件流和数据流。它是由 Netflix 开发并开源，现在广泛用于 Android 和 Java 后端开发。RxJava 提供了一种用于组合和处理异步数据的丰富工具集，它的核心思想是将数据流视为一系列事件，以响应事件的方式进行处理。RxJava 提供了丰富的操作符，用于处理和转换数据流。这些操作符可以帮助你执行各种操作，包括过滤、映射、合并、变换等，以便更好地处理异步数据流。
深入浅出RxJava(二：操作符)
热门推荐
大头鬼Bruce
03-06 10万+
RxJava operator介绍，介绍了RxJava中几种常见的operator的用法
RxJava 操作符
u010498248的博客
08-25 534
在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。
Rxjava功能操作符的使用方法详解
08-28
Rxjava功能操作符的使用方法详解 Rxjava是一个非常强大的Reactive Extensions库，提供了多种功能操作符来处理异步数据。下面我们将逐一介绍Rxjava功能操作符的使用方法详解。 一、Rxjava的基本概念 在Rxjava中，...
RxJava 操作符 图片
03-31
**RxJava 操作符详解** RxJava 是一个用于处理异步数据流的库，它引入了反应式编程的概念，使得事件处理变得更加灵活和易于管理。在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成...
rxjava-training:rxjava-培训
05-30
RxJava 的核心概念是观察者模式和函数式编程思想的融合，它提供了丰富的操作符来简化复杂的数据处理逻辑。 **观察者模式** 观察者模式是一种设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生...
Android-LearningRxJava(RxJava详解)
08-12
`Hello-RxJava-master`这个项目很可能是对RxJava的实战应用示例，包含各种使用场景和例子，包括上述提到的Schedulers、操作符和RxAndroid的用法。通过研究该项目，开发者可以深入理解RxJava在实际开发中的运用，并...
RxJava的使用详解
06-30
在这个详尽的讨论中，我们将深入理解RxJava的核心概念、操作符以及如何在实际项目中有效地使用它。 首先，让我们了解什么是反应式编程。反应式编程是一种编程范式，它强调数据流和变换，以及在变化的数据源上建立...
Android-Rxjava 常用操作符
风的轨迹
04-02 4705
Rxjava的优势 提高工作效率 能优雅的解决复杂的业务场景 1.Rxjava原理 RxJava 的原理就是创建一个 Observable 对象来干活，然后使用各种操作符建立起来的链式操作，就如同流水线一样，把你想要处理的数据一步一步地加工成你想要的成品，然后发射给 Subscriber 处理。 2.使用Rxjava需要添加的依赖 implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' implementation 'io.reactivex.
Rxjava操作符
qq_30172399的博客
05-13 483
目录一、RxJava操作符1、创建操作符 ：创建被观察者（Observable）对象&发送事件1）Create() 操作符2）Just() 操作符3）fromIterable() 操作符4）timer()操作符5）fromArray() 操作符6）interval() 定时器7）intervalRange() 操作符8）Range() 操作符2、转换操作符：变换被观察者(Observabl...
RxJava（一）创建操作符
牛永志的专栏
09-18 478
RxJava创建操作符
RxJava操作符总结
zhuhai__yizhi的专栏
12-13 539
（转载）http://www.jianshu.com/p/3b3345e6cea0 RxJava操作符 创建操作 Range Range操作符根据初始值n和数目m发射一系列大于等于n的m个值 Observable.range(5, 5).subscribe(new Action1() { @Override pub
Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印 方便用于小论文写作，方便用于毕业设计
最新发布
07-20
Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可导出高清图片，可修改，无水印。 方便用于小论文写作，方便用于毕业设计。 Visio版本为2021版，可用更高版本打开。 Visio绘制的Tanh激活函数图像,可
全面指南：中文版RxJava操作符详解与文档链接
文档按照章节组织，涵盖了RxJava的核心概念、主要类和操作符，以及错误处理、辅助功能和条件操作等关键部分。 1. **Observables**：RxJava的核心是Observables，它是事件流的抽象，可以观察值的变化。通过`from`、`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值