Android ：RxJava学习笔记之过滤操作符

最新推荐文章于 2022-07-30 13:10:26 发布
最新推荐文章于 2022-07-30 13:10:26 发布
阅读量516 收藏 1
点赞数 2
分类专栏： Android 文章标签： android rxjava java 过滤操作符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JMW1407/article/details/121137425
版权

RxJava ——过滤操作符

过滤操作符

顾名思义，这类operators主要用于对事件数据的筛选过滤，只返回满足我们条件的数据。

分类；

  • 1、根据 指定条件 过滤事件
  • 2、根据 指定事件数量 过滤事件
  • 3、根据 指定时间 过滤事件
  • 4、根据 指定事件位置 过滤事件
    在这里插入图片描述

1、根据 指定条件 过滤事件

在这里插入图片描述

1.1、Filter（）

filter(Func1)用来过滤观测序列中我们不想要的值，只返回满足条件的值，我们看下原理图：
在这里插入图片描述
在这里插入图片描述

Observable
       .create((ObservableOnSubscribe<Integer>) emitter -> {
         // 1. 发送5个事件
         emitter.onNext(1);
         emitter.onNext(2);
         emitter.onNext(3);
         emitter.onNext(4);
         emitter.onNext(5);
       }
       )
       .filter(integer -> {
         // 根据test()的返回值 对被观察者发送的事件进行过滤 & 筛选
         // a. 返回true，则继续发送
         // b. 返回false，则不发送（即过滤）
         return integer > 3;
         // 本例子 = 过滤了整数≤3的事件
       })
        .subscribe(new Observer<Integer>() {
          @Override
          public void onSubscribe(Disposable disposable) {
            System.out.println("对onSubscribe事件作出响应");
          }

          @Override
          public void onNext(Integer value) {
            System.out.println("接收到了事件"+ value );
          }

          @Override
          public void onError(Throwable e) {
            System.out.println("对Error事件作出响应" );
          }

          @Override
          public void onComplete() {
            System.out.println("对Complete事件作出响应");
          }
        });

输出

对onSubscribe事件作出响应
接收到了事件4
接收到了事件5

1.2、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.3、skip（） / skipLast（）

skip(int)让我们可以忽略Observable发射的前n项数据。
在这里插入图片描述
SkipLast：skipLast(int)忽略Observable发射的后n项数据。
在这里插入图片描述


    // 使用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 {
            System.out.println("Seq 获取到的整型事件元素是： "+ 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 {
            System.out.println("Time 获取到的整型事件元素是： "+ along);
          }
        });
    try {
      Thread.sleep(8000);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

在这里插入图片描述

1.4、distinct（） / distinctUntilChanged（）

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

distinct()的过滤规则是只允许还没有发射过的数据通过，所有重复的数据项都只会发射一次。
在这里插入图片描述
distinct(Func1)参数中的Func1中的call方法会根据Observable发射的值生成一个Key，然后比较这个key来判断两个数据是不是相同；如果判定为重复则会和distinct()一样过滤掉重复的数据项。

distinctUntilChanged()和distinct()类似，只不过它判定的是Observable发射的当前数据项和前一个数据项是否相同。
在这里插入图片描述

// 使用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);
                    }
                });

在这里插入图片描述

2、根据 指定事件数量 过滤事件

通过设置指定的事件数量，仅发送特定数量的事件

2.1、take（）

take(int)用一个整数n作为一个参数，从原始的序列中发射前n个元素.
在这里插入图片描述

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个事件

在这里插入图片描述

2.2、TakeLast

takeLast(int)同样用一个整数n作为参数，只不过它发射的是观测序列中后n个元素。

在这里插入图片描述

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

在这里插入图片描述

3、根据 指定时间 过滤事件

通过设置指定的时间，仅发送在该时间内的事件
在这里插入图片描述

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

在这里插入图片描述

3.2、Sample（）

在某段时间内，只发送该段时间内最新（最后）1次事件,与 throttleLast（） 操作符类似,仅需要把上文的 throttleLast（） 改成Sample（）操作符即可

3.3、throttleWithTimeout （） / debounce（）

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

debounce(long, TimeUnit)过滤掉了由Observable发射的速率过快的数据；如果在一个指定的时间间隔过去了仍旧没有发射一个，那么它将发射最后的那个。通常我们用来结合RxBing(Jake Wharton大神使用RxJava封装的Android UI组件)使用，防止button重复点击

在这里插入图片描述

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

在这里插入图片描述

4、根据 指定事件位置 过滤事件

通过设置指定的位置，过滤在该位置的事件
在这里插入图片描述

4.1、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);
                    }
                });

在这里插入图片描述

4.2、elementAt（）

elementAt(int)用来获取元素Observable发射的事件序列中的第n项数据，并当做唯一的数据发射出去。

在这里插入图片描述

// 使用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);
                    }
                });

在这里插入图片描述

4.3、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、Android：RxJava过滤操作符
2、RxJava系列4(过滤操作符)

JMW1407
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
JavaScript 学习笔记之操作符
12-07
一、一元操作符 1、自增自减操作符：分为前置型和后置型； 前置型：++a;–a; 后置型：a++;a–; 例： 代码如下:  [removed]  var a, b,i= 1,j=1;  a=i++;  b=++j;  alert(“a=”+a+”,i=”+i+”,b=”+b+”,...
RxJava使用（二）filter 操作符
tangxl2008008的专栏
05-06 6289
filter()操作符是可以对Observable流程的数据进行一层过滤处理，filter() 返回为 false 的值将不会发出到 Subscriber。         基本用法如下，下面的例子是过滤只保留偶数： Observable.just(1, 2, 3, 4)         .filter(new Func1() {             @Override
RxJava系列四（过滤操作符）
weixin_33889665的博客
01-18 99
转载请注明出处：https://zhuanlan.zhihu.com/p/21966621 RxJava系列1(简介) RxJava系列2(基本概念及使用介绍) RxJava系列3(转换操作符) RxJava系列4(过滤操作符) RxJava系列5(组合操作符) RxJava系列6(从微观角度解读RxJava源码) RxJava系列7(...
RxJava过滤操作符
tinysakura的博客
02-25 332
转载自LeiHolmes的博客[https://www.jianshu.com/p/66d4dacded9b] 前言 上一篇文章我们学习了转换类操作符，本篇我们将一起来学习RxJava过滤类操作符。过滤操作符主要是用来对事件数据进行过滤与筛选，只返回满足条件的数据，一起来看下都有哪些。 过滤操作符 Filter filter操作符，按照一定的约束条件过滤序列中我们不想要的数据，只返回满足条件的数据...
Android之Rxjava2.X 5————Rxjava 过滤操作符
冰炭不投day的博客
08-14 915
Android之Rxjava2.X 5————Rxjava 过滤操作符
RxJava系列4(过滤操作符)
苏白的专栏
09-01 783
作者：张磊(BaronZhang) 链接：https://zhuanlan.zhihu.com/p/21966621 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 前面一篇文章中我们介绍了转换类操作符，那么这一章我们就来介绍下过滤类的操作符。顾名思义，这类operators主要用于对事件数据的筛选过滤，只返回满足我们条件的数据。过滤类操作符主要包含：
JavaScript 学习笔记之操作符（续）
01-19
一、乘性操作符 1、乘法：*  乘法操作符的一些特殊规则： 如果操作数都是数值，按照常规的乘法计算，如果乘积超过了ECMAscript数值的表示范围，则返回infinity或者-infinity 如果有一个操作数是NaN，那返回结果就是...
Android学习笔记：横屏竖屏的切换
03-02
我们需要写两个AndroidXML文件，假定文件为chapter_19_test1.xml,放在常规目录位置layout/内容如下：另一个位于layout-land/目录下面，文件名称一样，这里是landsapce的排版，简单地，我们只作少许改动，将...
RxJava从入门到不离不弃（四）——过滤操作符
jiashuai94的博客
08-21 277
RxJava中的过滤操作符，顾名思义，这类操作符主要用于对事件数据的筛选过滤，只返回满足我们条件的数据。 我们试想一下这样的一个需求，有一个学生集合，要求将其中成绩不及格的学生过滤，返回成绩合格的学生集合，如果平时一般会怎么做呢？可能会这样实现： List&amp;lt;Student&amp;gt; newList = new ArrayList&amp;lt;&amp;gt;(); for (int i = 0; i...
Carson带你学Android：RxJava过滤操作符
Carson带你学Android
12-01 6360
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的 过滤操作符，希望你们会喜
4. RxJava过滤操作符
NorthStar的博客
07-30 587
RxJava过滤操作符
RXJAVA-filter
大新博客
02-23 558
Filter你会很常用的，它的作用也很简单，过滤器嘛。可以接受一个参数，让其过滤掉不符合我们条件的值。 package com.netty.demo.vertx; import io.reactivex.*; import io.reactivex.functions.Consumer; import io.reactivex.functions.Predicate; import lombok.extern.slf4j.Slf4j; @Slf4j public class RxJavaTest .
android rxjava 过滤,RxJava(六)：过滤操作符
weixin_30340301的博客
05-26 290
RxJava 的过滤操作符主要包括以下几种：filter：过滤数据takeLast：只发射最后的 N 项数据last ：只发射最后一项数据lastOrDefault：只发射最后一项数据，如果 Observable 空，就发射默认值。takeLastBuffer ：将最后的 N 项数据当作单个数据发射skip ：跳过开始的 N 项数据skipLast：跳过最后的 N 项数据take ：只发射开始的 ...
RxJava—过滤操作符
不忘初心
04-22 773
1.前言        在前一篇文章中向大家介绍了转换操作符，如果对转换操作符不是很清楚的建议可以去看一下RxJava—转换操作符。那么在这一章中我们就来介绍RxJava中的过滤操作符，顾名思义过滤操作符主要就是对事件数据根据相应的条件进行过滤，只返回满足过滤条件的数据，过滤操作符主要包括：Filter、Take、TakeLast、TakeUntil、Skip、SkipLast、ElementA
Rxjava 过滤操作符
hongxue8888的博客
09-25 149
文章目录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 578
RxJava-过滤操作符过滤操作符相对来说比较简单和易于理解，（建议在学习这些过滤操作符的时候，点进源码查看一下具体使用的过滤函数，因为Rx有很多平台的语言，可能为了与其他平台一致，所以有很多功能实际相同的函数，很多操作符内部调用了其他操作符，可以加深理解） filter( ) — 过滤数据 takeLast( ) — 只发射最后的N项数据 last( ) — 只发射最后的一项数据 lastOrDe
RxJava之过滤操作符的使用
程序员吗？
12-04 155
过滤操作符也是在上游和下游之间插入，主要用来进行数据的过滤 主要实现过程如下： 1，filter操作符 Observable.just("zhan","san","li","si") .filter(new Predicate<String>() { @Override public boolean test(String s) throws Exception {
Rxjava操作符之过滤操作符
qq_15327675的博客
11-09 320
1.过滤操作符的作用:过滤/筛选 被观察者(Observable)发送的事件 以及  观察者(Observer)接收的事件 rxjava2中的常见的过滤操作符有以下的常见类型: 2.根据指定条件过滤事件 需求场景为:通过设置指定的过滤条件，当且仅当该事件满足条件，就将该事件过滤（不发送） 2.1 filter()过滤操作符 //过滤操作符之filter() ...
RxJava 过滤操作符 distinct和elementAt
小炫风技术旅行
02-29 3229
distinct类似于sql关键字distinct 去重,elementAt 获取指定索引的结果 例子1:去重 Observable.just(1, 2, 3, 1, 2, 3, 12, 3).distinct().subscribe(new Action1() { @Override public void call(Integer inte
Android学习笔记技巧之给文本加边框
最新发布
06-01
要给文本加边框，可以使用 Android 中的 Shape Drawable，下面是具体的步骤： 1. 在 res/drawable 文件夹中创建一个 XML 文件，比如说叫做 text_border.xml。 2. 在 text_border.xml 中添加以下代码： ``` <shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle"> <stroke android:width="1dp" android:color="@color/black" /> <padding android:left="5dp" android:top="5dp" android:right="5dp" android:bottom="5dp" /> </shape> ``` 其中，stroke 标签用于设置边框的宽度和颜色，padding 标签用于设置文本与边框之间的距离。 3. 在布局文件中使用 TextView，添加 android:background="@drawable/text_border" 属性即可实现给文本加边框的效果。 例如： ``` <TextView android:id="@+id/my_textview" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Hello World!" android:background="@drawable/text_border" /> ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值