Android RxJava 操作符详解系列：过滤操作符

最新推荐文章于 2022-07-30 13:10:26 发布
最新推荐文章于 2022-07-30 13:10:26 发布
阅读量301 收藏
点赞数
分类专栏： Android开发

前言

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

Github截图

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


  • RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求
  • 今天，我将为大家详细介绍RxJava操作符中最常用的 过滤操作符，希望你们会喜欢。 

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

目录

示意图

1. 作用

过滤 / 筛选 被观察者（Observable）发送的事件 & 观察者 （Observer）接收的事件

2. 类型

  • RxJava2中，过滤操作符的类型包括： 
    示意图

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

3. 应用场景 & 对应操作符详解

  • 过滤操作符的应用场景包括：

    1. 根据 指定条件 过滤事件
    2. 根据 指定事件数量 过滤事件
    3. 根据 指定时间 过滤事件
    4. 根据 指定事件位置 过滤事件

  • 下面，我将根据上述应用场景，讲解对应的操作符使用

注：在使用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 根据 指定条件 过滤事件

  • 需求场景 
    通过设置指定的过滤条件，当且仅当该事件满足条件，就将该事件过滤（不发送）

  • 对应操作符类型

示意图

  • 对应操作符使用

Filter（）

  • 作用 
    过滤 特定条件的事件

  • 原理

示意图

  • 具体使用
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 1. 发送5个事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onNext(5);
            }

            // 2. 采用filter（）变换操作符
        }).filter(new Predicate<Integer>() {
            // 根据test()的返回值 对被观察者发送的事件进行过滤 & 筛选
              // a. 返回true，则继续发送
              // b. 返回false，则不发送（即过滤）
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 3;
                // 本例子 = 过滤了整数≤3的事件
            }
        }).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
  • 40
  • 41
  • 42
  • 43
  • 测试结果

示意图

ofType（）

  • 作用 
    过滤 特定数据类型的数据

  • 具体使用

Observable.just(1, "Carson", 3, "Ho", 5)
                  .ofType(Integer.class) // 筛选出 整型数据
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"获取到的整型事件元素是： "+ integer);
                      }
        });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 测试结果

示意图

skip（） / skipLast（）

  • 作用 
    跳过某个事件

  • 具体使用

// 使用1：根据顺序跳过数据项
        Observable.just(1, 2, 3, 4, 5)
                .skip(1) // 跳过正序的前1项
                .skipLast(2) // 跳过正序的后2项
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"获取到的整型事件元素是： "+ integer);
                      }
        });

// 使用2：根据时间跳过数据项
        // 发送事件特点：发送数据0-5，每隔1s发送一次，每次递增1；第1次发送延迟0s
        Observable.intervalRange(0, 5, 0, 1, TimeUnit.SECONDS)
                .skip(1, TimeUnit.SECONDS) // 跳过第1s发送的数据
                .skipLast(1, TimeUnit.SECONDS) // 跳过最后1s发送的数据
                .subscribe(new Consumer<Long>() {

                    @Override
                    public void accept( Long along ) throws Exception {
                        Log.d(TAG,"获取到的整型事件元素是： "+ along);
                    }
                });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 测试结果

image.png

distinct（） / distinctUntilChanged（）

  • 作用 
    过滤事件序列中重复的事件 / 连续重复的事件

  • 具体使用

// 使用1：过滤事件序列中重复的事件
        Observable.just(1, 2, 3, 1 , 2 )
                .distinct()
                .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"不重复的整型事件元素是： "+ integer);
                      }
        });

        // 使用2：过滤事件序列中 连续重复的事件
        // 下面序列中，连续重复的事件 = 3、4
        Observable.just(1,2,3,1,2,3,3,4,4 )
                .distinctUntilChanged()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"不连续重复的整型事件元素是： "+ integer);
                    }
                });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 测试结果

示意图

3.2 根据 指定事件数量 过滤事件

  • 需求场景 
    通过设置指定的事件数量，仅发送特定数量的事件

  • 对应操作符类型 
    take（） & takeLast（）

  • 对应操作符使用

take（）

  • 作用 
    指定观察者最多能接收到的事件数量

  • 原理

示意图

  • 具体使用
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 1. 发送5个事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onNext(4);
                emitter.onNext(5);
            }

            // 采用take（）变换操作符
            // 指定了观察者只能接收2个事件
        }).take(2)
        .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事件作出响应");
            }
        });

// 实际上，可理解为：被观察者还是发送了5个事件，只是因为操作符的存在拦截了3个事件，最终观察者接收到的是2个事件
 
 
  • 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
  • 测试结果

示意图

takeLast（）

  • 作用 
    指定观察者只能接收到被观察者发送的最后几个事件

  • 具体使用

Observable.just(1, 2, 3, 4, 5)
          .takeLast(3) //指定观察者只能接受被观察者发送的3个事件
          .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
  • 测试结果

示意图

3.3 根据 指定时间 过滤事件

  • 需求场景 
    通过设置指定的时间，仅发送在该时间内的事件

  • 对应操作符类型

示意图

  • 对应操作符使用

throttleFirst（）/ throttleLast（）

  • 作用 
    在某段时间内，只发送该段时间内第1次事件 / 最后1次事件

    如，1段时间内连续点击按钮，但只执行第1次的点击操作

  • 原理示意图

示意图

  • 具体使用
<<- 在某段时间内，只发送该段时间内第1次事件 ->>
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 隔段事件发送时间
                e.onNext(1);
                Thread.sleep(500);

                e.onNext(2);
                Thread.sleep(400);

                e.onNext(3);
                Thread.sleep(300);

                e.onNext(4);
                Thread.sleep(300);

                e.onNext(5);
                Thread.sleep(300);

                e.onNext(6);
                Thread.sleep(400);

                e.onNext(7);
                Thread.sleep(300);
                e.onNext(8);

                Thread.sleep(300);
                e.onNext(9);

                Thread.sleep(300);
                e.onComplete();
            }
        }).throttleFirst(1, TimeUnit.SECONDS)//每1秒中采用数据
                .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次事件 ->>
Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 隔段事件发送时间
                e.onNext(1);
                Thread.sleep(500);

                e.onNext(2);
                Thread.sleep(400);

                e.onNext(3);
                Thread.sleep(300);

                e.onNext(4);
                Thread.sleep(300);

                e.onNext(5);
                Thread.sleep(300);

                e.onNext(6);
                Thread.sleep(400);

                e.onNext(7);
                Thread.sleep(300);
                e.onNext(8);

                Thread.sleep(300);
                e.onNext(9);

                Thread.sleep(300);
                e.onComplete();
            }
        }).throttleLast(1, TimeUnit.SECONDS)//每1秒中采用数据
                .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
  • 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
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 测试结果

示意图

Sample（）

  • 作用 
    在某段时间内，只发送该段时间内最新（最后）1次事件

    与 throttleLast（） 操作符类似

  • 具体使用

仅需要把上文的 throttleLast（） 改成Sample（）操作符即可，此处不作过多描述

throttleWithTimeout （） / debounce（）

  • 作用 
    发送数据事件时，若2次发送事件的间隔＜指定时间，就会丢弃前一次的数据，直到指定时间内都没有新数据发射时才会发送后一次的数据

  • 具体使用

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                // 隔段事件发送时间
                e.onNext(1);
                Thread.sleep(500);
                e.onNext(2); // 1和2之间的间隔小于指定时间1s，所以前1次数据（1）会被抛弃，2会被保留
                Thread.sleep(1500);  // 因为2和3之间的间隔大于指定时间1s，所以之前被保留的2事件将发出
                e.onNext(3);
                Thread.sleep(1500);  // 因为3和4之间的间隔大于指定时间1s，所以3事件将发出
                e.onNext(4);
                Thread.sleep(500); // 因为4和5之间的间隔小于指定时间1s，所以前1次数据（4）会被抛弃，5会被保留
                e.onNext(5);
                Thread.sleep(500); // 因为5和6之间的间隔小于指定时间1s，所以前1次数据（5）会被抛弃，6会被保留
                e.onNext(6);
                Thread.sleep(1500); // 因为6和Complete实践之间的间隔大于指定时间1s，所以之前被保留的6事件将发出

                e.onComplete();
            }
        }).throttleWithTimeout(1, TimeUnit.SECONDS)//每1秒中采用数据
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @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.4 根据 指定事件位置 过滤事件

  • 需求场景 
    通过设置指定的位置，过滤在该位置的事件

  • 对应操作符类型

示意图

  • 对应操作符使用

firstElement（） / lastElement（）

  • 作用 
    仅选取第1个元素 / 最后一个元素

  • 具体使用

// 获取第1个元素
        Observable.just(1, 2, 3, 4, 5)
                  .firstElement()
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"获取到的第一个事件是： "+ integer);
                      }
        });

// 获取最后1个元素
        Observable.just(1, 2, 3, 4, 5)
                .lastElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"获取到的最后1个事件是： "+ integer);
                    }
                });

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 测试结果

示意图

elementAt（）

  • 作用 
    指定接收某个元素（通过 索引值 确定）

    注：允许越界，即获取的位置索引 ＞ 发送事件序列长度

  • 具体使用

// 使用1：获取位置索引 = 2的 元素
        // 位置索引从0开始
        Observable.just(1, 2, 3, 4, 5)
                  .elementAt(2)
                  .subscribe(new Consumer<Integer>() {
                      @Override
                      public void accept( Integer integer) throws Exception {
                          Log.d(TAG,"获取到的事件元素是： "+ integer);
                      }
        });

// 使用2：获取的位置索引 ＞ 发送事件序列长度时，设置默认参数
        Observable.just(1, 2, 3, 4, 5)
                .elementAt(6,10)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"获取到的事件元素是： "+ integer);
                    }
                });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 测试结果

示意图

elementAtOrError（）

  • 作用 
    在elementAt（）的基础上，当出现越界情况（即获取的位置索引 ＞ 发送事件序列长度）时，即抛出异常

  • 具体使用

Observable.just(1, 2, 3, 4, 5)
                .elementAtOrError(6)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept( Integer integer) throws Exception {
                        Log.d(TAG,"获取到的事件元素是： "+ integer);
                    }
                });
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 测试结果

示意图

至此，RxJava2中常用的过滤操作符讲解完毕。

4. 实际开发需求案例

  • 在实际开发中，常见的过滤操作符实际需求场景有：功能防抖 & 联想搜索请求优化
  • 下面，我将通过具体实例来讲解上述2个需求

4.1 功能防抖

  • 需求场景

示意图

4.2 联想搜索优化

  • 场景说明

示意图

5. Demo地址

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

6. 总结

  • 下面，我将用一张图总结 RxJava2 中常用的条件 / 布尔操作符

示意图


    IT-Oliver
    关注
    • 0
      点赞
    • 踩
    • 0
      收藏
      觉得还不错? 一键收藏
    • 0
      评论
    专栏目录
    Android RxJava使用介绍（三） RxJava的操作符
    呼啸而过的专栏
    06-23 2万+
    上一篇文章已经详细讲解了RxJava的创建型操作符，本片文章将继续讲解RxJava操作符，包括： Transforming Observables(Observable的转换操作符) Filtering Observables(Observable的过滤操作符)
    Carson带你学Android：RxJava过滤操作符
    Carson带你学Android
    12-01 6426
    前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的 过滤操作符，希望你们会喜
    Android RxJava操作符一览
    baiiu
    06-10 6863
    前言把现在接触到的操作符全部整理进来，方便查阅，遇到新的也会添加进来。和RxJavaLearn 的README.md同步更新。操作符决策树 直接创建一个Observable（创建操作） 组合多个Observable（组合操作） 对Observable发射的数据执行变换操作（变换操作） 从Observable发射的数据中取特定的值（过滤操作） 转发Observable的部分值（条件/布尔/过滤操作）
    RxJava过滤操作符
    tinysakura的博客
    02-25 352
    转载自LeiHolmes的博客[https://www.jianshu.com/p/66d4dacded9b] 前言 上一篇文章我们学习了转换类操作符，本篇我们将一起来学习RxJava过滤类操作符。过滤操作符主要是用来对事件数据进行过滤与筛选，只返回满足条件的数据，一起来看下都有哪些。 过滤操作符 Filter filter操作符，按照一定的约束条件过滤序列中我们不想要的数据，只返回满足条件的数据...
    RxJava从入门到不离不弃（四）——过滤操作符
    jiashuai94的博客
    08-21 289
    RxJava中的过滤操作符，顾名思义，这类操作符主要用于对事件数据的筛选过滤，只返回满足我们条件的数据。 我们试想一下这样的一个需求，有一个学生集合，要求将其中成绩不及格的学生过滤，返回成绩合格的学生集合，如果平时一般会怎么做呢？可能会这样实现： List&amp;lt;Student&amp;gt; newList = new ArrayList&amp;lt;&amp;gt;(); for (int i = 0; i...
    Rxjava功能操作符的使用方法详解
    08-28
    Rxjava功能操作符的使用方法详解 Rxjava是一个非常强大的Reactive Extensions库，提供了多种功能操作符来处理异步数据。下面我们将逐一介绍Rxjava功能操作符的使用方法详解。 一、Rxjava的基本概念 在Rxjava中，...
    RxJava 操作符 图片
    03-31
    **RxJava 操作符详解** RxJava 是一个用于处理异步数据流的库，它引入了反应式编程的概念，使得事件处理变得更加灵活和易于管理。在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成...
    基于Rxjava2的事件总线：Rxbus
    09-01
    在RxJava2中，核心概念包括Observable（可观察者）和Observer（观察者），以及一系列的操作符，如map、filter、merge等，用于对数据流进行转换和过滤。 **RxBus设计思想** RxBus的核心思想是利用RxJava2的...
    《给 Android 开发者的 RxJava 详解》 PDF
    08-29
    1. **基本操作符**：RxJava 提供了一系列操作符，如 map、filter、reduce、concatMap、flatMap 等，它们可以对数据流进行转换、过滤、组合等操作，帮助开发者更精细地控制数据处理流程。 2. **线程控制**：在 ...
    给 Android 开发者的 RxJava 详解
    04-14
    以下是一些常用的操作符： - **map()**: 对每个发送的数据项应用一个函数，将其转换为新的数据项。 - **filter()**: 过滤掉不符合条件的数据项。 - **concatMap()**: 将每个数据项转换为一个新的 `Observable`，并...
    Carson带你学Android：RxJava功能性操作符
    Carson带你学Android
    11-15 7733
    前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的 功能性操作符，并附带 R
    RxJava系列4(过滤操作符)
    苏白的专栏
    09-01 789
    作者：张磊(BaronZhang) 链接：https://zhuanlan.zhihu.com/p/21966621 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 前面一篇文章中我们介绍了转换类操作符，那么这一章我们就来介绍下过滤类的操作符。顾名思义，这类operators主要用于对事件数据的筛选过滤，只返回满足我们条件的数据。过滤类操作符主要包含：
    4. RxJava过滤操作符
    NorthStar的博客
    07-30 623
    RxJava过滤操作符
    Android RxJava之操作符
    weixin_40929353的博客
    09-27 347
    最近参照文档对RxJava一系列操作符作了一下理解。 一、创建类操作符 1、Create 创建一个Observable，返回一个emitter（发射器），手动调用onNext()，onError()，onComplete()方法。 2、from Array，Just 创建一个将要发出的一个或一组对象的Observable，会自行调用onNext()，onComplete方法。Just...
    RxJava—过滤操作符
    不忘初心
    04-22 787
    1.前言        在前一篇文章中向大家介绍了转换操作符，如果对转换操作符不是很清楚的建议可以去看一下RxJava—转换操作符。那么在这一章中我们就来介绍RxJava中的过滤操作符，顾名思义过滤操作符主要就是对事件数据根据相应的条件进行过滤，只返回满足过滤条件的数据，过滤操作符主要包括：Filter、Take、TakeLast、TakeUntil、Skip、SkipLast、ElementA
    Rxjava 过滤操作符
    hongxue8888的博客
    09-25 156
    文章目录1 filter2 take3 distinct4 elementAt 参考：https://www.jianshu.com/p/c3a930a03855 作用 ：对多个事件进行过滤 filter take distinct elementAt （指定） 1 filter 例如：一堆商品中选出已经过期的商品 其他的不处理 @Test public vo...
    RxJava-过滤操作符
    Knight-ZXW的博客
    04-05 586
    RxJava-过滤操作符过滤操作符相对来说比较简单和易于理解，（建议在学习这些过滤操作符的时候，点进源码查看一下具体使用的过滤函数，因为Rx有很多平台的语言，可能为了与其他平台一致，所以有很多功能实际相同的函数，很多操作符内部调用了其他操作符，可以加深理解） filter( ) — 过滤数据 takeLast( ) — 只发射最后的N项数据 last( ) — 只发射最后的一项数据 lastOrDe
    RxJava【过滤】操作符 filter distinct throttle take skip first MD
    weixin_34148456的博客
    09-26 142
    Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina.com RxJava【过滤】操作符 filter distinct throttle take skip first MD demo地址...
    Rxjava操作符之过滤操作符
    qq_15327675的博客
    11-09 327
    1.过滤操作符的作用:过滤/筛选 被观察者(Observable)发送的事件 以及  观察者(Observer)接收的事件 rxjava2中的常见的过滤操作符有以下的常见类型: 2.根据指定条件过滤事件 需求场景为:通过设置指定的过滤条件，当且仅当该事件满足条件，就将该事件过滤（不发送） 2.1 filter()过滤操作符 //过滤操作符之filter() ...
    RxJava 4.0中文文档详解：核心概念与操作符指南
    6. **Operators**（操作符）：这是RxJava的核心，提供了丰富的功能，如创建、转换、过滤、合并等，用于处理和操纵数据流。文档列出了众多操作符，如 `Create`（创建新的 Observable）、`Map`（转换数据）、`Filter`...
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值