Android RxJava操作符详解系列： 创建操作符

最新推荐文章于 2022-04-12 15:31:19 发布
最新推荐文章于 2022-04-12 15:31:19 发布
阅读量374 收藏
点赞数
分类专栏： Android开发
本文详细介绍了RxJava2中常用的创建操作符，包括create、just、fromArray等，并通过示例展示了如何使用这些操作符创建被观察者对象及发送事件。此外，还讲解了一个实际需求案例：网络请求轮询。

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

前言

  • Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。

Github截图

如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程


  • RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求
  • 今天，我将为大家详细介绍RxJava操作符中最常用的创建操作符，并附带 Retrofit 结合 RxJava的实例Demo教学，希望你们会喜欢。 

  1. 本系列文章主要基于 Rxjava 2.0 
  2. 接下来的时间，我将持续推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操作符、应用场景、背压等等 ，有兴趣可以继续关注Carson_Ho的安卓开发笔记！！
    示意图

目录

示意图

1. 作用

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

2. 类型

  • 创建操作符包括如下：

示意图

  • 下面，我将对每个操作符进行详细介绍

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

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

dependencies {
      compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
      compile 'io.reactivex.rxjava2:rxjava:2.0.7'
      // 注：RxJava2 与 RxJava1 不能共存，即依赖不能同时存在
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

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();
            }
        });

// 至此，一个完整的被观察者对象（Observable）就创建完毕了。


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

在具体使用时，一般采用 链式调用 来创建

        // 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>() {
            // 以下步骤仅为展示一个完整demo，可以忽略
            // 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事件作出响应");
            }

        });
    }

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 测试结果

示意图

3.2 快速创建 & 发送事件

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

  • 对应操作符类型

just（）

  • 作用 

    1. 快速创建1个被观察者对象（Observable）
    2. 发送事件的特点：直接发送 传入的事件 

    注：最多只能发送10个参数

  • 应用场景 
    快速创建 被观察者对象（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事件作出响应");
            }

        });
    }
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 测试结果

示意图

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, "遍历结束");
                    }

                });

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 测试结果

发送事件

数组遍历

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, "遍历结束");
                    }
                });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 测试结果

发送集合

集合遍历

额外

// 下列方法一般用于测试使用

<-- empty()  -->
// 该方法创建的被观察者对象发送事件的特点：仅发送Complete事件，直接通知完成
Observable observable1=Observable.empty(); 
// 即观察者接收后会直接调用onCompleted（）

<-- error()  -->
// 该方法创建的被观察者对象发送事件的特点：仅发送Error事件，直接通知异常
// 可自定义异常
Observable observable2=Observable.error(new RuntimeException())
// 即观察者接收后会直接调用onError（）

<-- never()  -->
// 该方法创建的被观察者对象发送事件的特点：不发送任何事件
Observable observable3=Observable.never();
// 即观察者接收后什么都不调用

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

3.3 延迟创建

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

defer（）

  • 作用 
    直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件

    1. 通过 Observable工厂方法创建被观察者对象（Observable）
    2. 每次订阅后，都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的

  • 应用场景 
    动态创建被观察者对象（Observable） & 获取最新的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事件作出响应");
            }
        });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 测试结果

因为是在订阅时才创建，所以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) 
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 测试结果

示意图

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)
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 测试结果

示意图

intervalRange（）

  • 作用 

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

    a. 发送的事件序列 = 从0开始、无限递增1的的整数序列 
    b. 作用类似于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事件作出响应");
                    }

                });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 测试结果

示意图

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事件作出响应");
                    }

                });

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 测试结果

示意图

rangeLong（）

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

至此，关于 RxJava2中的创建操作符讲解完毕。

4. 实际开发需求案例

5. Demo地址

上述所有的Demo源代码都存放在：Carson_Ho的Github地址：RxJava2_创建操作符

6. 总结

  • 下面，我将用1张图总结 RxJava2 中常用的创建操作符

示意图


Android RxJava使用介绍（三） RxJava的操作符
呼啸而过的专栏
06-23 2万+
上一篇文章已经详细讲解了RxJava的创建型操作符，本片文章将继续讲解RxJava操作符，包括： Transforming Observables(Observable的转换操作符) Filtering Observables(Observable的过滤操作符)
Android RxJava之操作符
weixin_40929353的博客
09-27 426
最近参照文档对RxJava一系列操作符作了一下理解。 一、创建类操作符 1、Create 创建一个Observable，返回一个emitter（发射器），手动调用onNext()，onError()，onComplete()方法。 2、from Array，Just 创建一个将要发出的一个或一组对象的Observable，会自行调用onNext()，onComplete方法。Just...
Carson带你学Android：RxJava创建操作符
Carson带你学Android
10-16 1万+
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的创建操作符，并附带 Ret
Android RxJava操作符一览
baiiu
06-10 6951
前言把现在接触到的操作符全部整理进来，方便查阅，遇到新的也会添加进来。和RxJavaLearn 的README.md同步更新。操作符决策树 直接创建一个Observable（创建操作） 组合多个Observable（组合操作） 对Observable发射的数据执行变换操作（变换操作） 从Observable发射的数据中取特定的值（过滤操作） 转发Observable的部分值（条件/布尔/过滤操作）
Carson带你学Android：手把手带你入门神秘的Rxjava
Carson带你学Android
10-09 3万+
前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。本文主要：面向 刚接触Rxjava的初学者 提供了一份 清晰、简洁、易懂的Rxjava入门教程 涵盖 基本介绍、原理 & 具体使用等解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题 希望你们会喜欢。 本文主要基于Rxjava 2.0 如果读者还没学习过Rx
RxJava功能操作符详解：提升Android开发效率的关键
接下来，我们将探讨一些常见的 RxJava 操作符： - `map()`：用于转换数据流中的每个元素，例如将 JSON 对象转换成 Java 对象。 ```java Flowable<String> jsonString = ...; Flowable<JSONObject> ...
RxJava操作符详解与实践：掌握创建、变换与错误处理
### RxJava 操作符使用整理 #### 知识点概述 RxJava 是一个响应式编程库，它通过使用可观察序列来构建异步和基于事件的程序。...希望以上的整理能够帮助你更好地掌握RxJava操作符的使用，提升编程效率和代码质量。
Android RxJava： 这是一份全面的 操作符 使用汇总 ，安卓开发基础面试题
m0_69439527的博客
04-12 338
近两年“程序员职业发展”话题，受到越来越多关注，做技术还是转管理？如何保持竞争力？是否要转换新的技术栈？ 每个工作三五年的程序员，都正面临着类似的焦虑。 工作三五年，不能像刚入职场凭着一股子冲劲和能吃苦耐劳的精神赢得升职加薪，而转型管理，是很多技术人员的梦想。 那么，技术骨干朝着管理人才前进的过程中，应该如何培养其管理能力呢? compile ‘io.reactivex.rxjava2:rxjava:2.0.7’ // 注：RxJava2 与 RxJava1 不能共存，即依赖不能同时存在 } 3.1 创建.
RxJava 操作符 图片
03-31
**RxJava 操作符详解** RxJava 是一个用于处理异步数据流的库，它引入了反应式编程的概念，使得事件处理变得更加灵活和易于管理。在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成...
Rxjava功能操作符的使用方法详解
08-28
Rxjava功能操作符的使用方法详解 Rxjava是一个非常强大的Reactive Extensions库，提供了多种功能操作符来处理异步数据。下面我们将逐一介绍Rxjava功能操作符的使用方法详解。 一、Rxjava的基本概念 在Rxjava中，...
深入浅出RxJava(二：操作符)
热门推荐
大头鬼Bruce
03-06 10万+
RxJava operator介绍，介绍了RxJava中几种常见的operator的用法
Android之Rxjava2.X 2————Rxjava 创建操作符
冰炭不投day的博客
08-13 1837
Android之Rxjava2.X 2————Rxjava 创建操作符 一.目录 Android之Rxjava2.X 2————Rxjava 创建操作符 一.目录 二.概述 1.作用 2. 类型 三.基本创建 1. create（） 四.快速创建 1.just() 2.fromArray（） 3.fromIterable（） 4.其他 五. 延迟创建 1.defer（） ...
Android ：RxJava学习笔记之创建操作符
JMW1407的博客
10-31 1110
RxJava ——创建操作符 创建操作符1、creat2、just3、from4、defer、interval 和 timer4.1 defer4.2 interval4.3timer5、range()参考 创建操作符 1、creat 使用一个函数从头开始创建一个 Observable 我们可以使用 create 操作符从头开始创建一个 Observable 给这个操作符传递一个接受观察者作为参数的函数，编写这个函数让它的行为表现为一个 Observable ——恰当地调用观察者 onNext、onE
Android RxJava应用：变换操作符
Carson带你学Android
10-23 1万+
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的变换操作符，并附带 Ret
从零开始的RxJava2.0教程(二)操作符
宇不语的博客
11-06 2万+
1. 前言在上一篇中，我介绍了RxJava 2.0的一些基础知识，同时也介绍了map()操作符。这篇blog将介绍许多RxJava中的操作符，RxJava的强大性就来自于它所定义的操作符。 首先先看一个例子： 2. 准备工作假设我的 Flowable 发射的是一个列表，接收者要把列表内容依次输出。根据上一篇blog的内容，你可以会写出这样的代码:List<Integer> list = new
Android RxJava：详解 条件 / 布尔操作符
栀夏暖阳的博客
03-16 303
目录 目录 1. 作用 通过设置函数，判断被观察者（Observable）发送的事件是否符合条件 2. 类型 RxJava2中，条件 / 布尔操作符的类型包括： 示意图 下面，我将对每个操作符进行详细讲解 3. 具体操作符详解 注：在使用RxJava 2操作符前，记得在项目的Gradle中添加依赖： dependencies { compile 'i...
给 Android 开发者的 RxJava 详解
qq_32290639的博客
09-03 125
给 Android 开发者的 RxJava 详解 掘金：RxJava2 只看这一篇文章就够了 RxJava 的基本使用用法(一) RxJava 详解——简洁的异步操作（二）
【Android】RxJava之操作符
weixin_33774883的博客
11-18 145
开始前 上节初步了解了RxJava，本节主要讲讲RxJava的操作符。官方文档中可以看到操作符特别的多，同样也是RxJava比较重要的内容，在我看来灵活使用RxJava离不开对它的操作符的理解。那本节就根据图书《RxJava　Essentials》上操作符的描述，根据操作符类型分类分别介绍一些操作符的使用。另外本节引用了RxJava-An...
RxJava使用指南
perry_Fan
10-09 752
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 &amp; 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解RxJava，请看文章：Android：这是一篇 清晰 &amp; 易懂的Rxjava 入门教程   RxJava如此受欢迎的原因，在于其提供了丰富 &amp; 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家献上一份 RxJava操...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值