RxJava操作符（五） ----过滤操作符

最新推荐文章于 2023-05-16 15:30:14 发布
最新推荐文章于 2023-05-16 15:30:14 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： 学习笔记 文章标签： rxjava observable 操作符 过滤
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengke1993/article/details/80392508
版权
RxJava各类型操作符详解如下：

RxJava操作符汇总
RxJava操作符（一） —-创建操作符
RxJava操作符（二）—-转换操作符
RxJava操作符（三）—-合并操作符
RxJava操作符（四）—-功能操作符
RxJava操作符（五） —-过滤操作符
RxJava操作符（六）—-条件操作符

过滤操作符： 用于将Observable发送的数据进行过滤和选择。让Observable返回我们所需要的数据。 过滤操作符有buffer()，filter()，skip()，take()，skipLast()，takeLast()，throttleFirst()，distainctUntilChange()。

1、filter() 操作符 

  /**
     * ========================filter() 操作符 ======================================
     * 
     * 对被观察者发送的事件做过滤操作。只有符合筛选条件的事件才会被观察者所接收。
     * 
     * return true : 继续发送
     * 
     * return false ： 不发送
     */
    public static void filter() {

        Observable
                .create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        for (int i = 0; i < 3; i++) {
                            emitter.onNext(i);
                        }
                    }
                })
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        //return true : 继续发送
                        //return false ： 不发送
                        return integer != 2; // 本例子过滤了 等于2的情况
                    }
                })
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "filter", String.valueOf(integer));
                    }
                });

    }

输出如下：

1

2、distinct() 操作符

/**
     * ========================distinct 操作符 ======================================
     * 
     * 简单地说就是去重。发射的数据包含重复的，会将重复的筛选掉。也就是，它只允许还没有被发射过的数据通过，被观察者接收。发射完数据会自动调用onComplete()方法
     * 
     * y以下代码：观察者只会接收到 ： 1,2,3,5 四个数值
     */
    public static void distinct() {
        Observable
                .just(1, 2, 3, 2, 3, 5)
                .distinct()
                .subscribe(
                        new Observer<Integer>() {
                            @Override
                            public void onSubscribe(Disposable d) {

                            }

                            @Override
                            public void onNext(Integer integer) {
                                Log.d(TAG + "distinct", String.valueOf(integer));
                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {
                                Log.d(TAG + "distinct", "onComplete");
                            }
                        });

    }

输出如下：

2

3、distinctUntilChanged() 操作符

 /**
     * ========================distinctUntilChanged 操作符 ======================================
     * 
     * 过滤掉连续重复的事件
     */
    public static void distinctUntilChanged() {
        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, String.valueOf(integer));
                    }
                });
    }

输出如下：

3

4、skip()，skipLast()操作符


    /**
     * ========================skip，skipLast======================================
     *
     *  skip 操作符是把Observable发射的数据过滤点掉前n项。而take操作符只能接收前n项。另外还有skipLast和takeLast则是从后往前进行过滤.接收完会调用onComplete()方法
     *
     */

    /**
     * 以下代码输出： 3,4,5
     */
    public static void skip() {
        Observable
                .just(1, 2, 3, 4, 5, 6, 7)
                .skip(2)  //过滤前2项
                .skipLast(3) //过滤后3项
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG + "skip", "根据顺序过滤" + String.valueOf(integer));
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG + "skip", "onComplete");
                    }
                });
//-------------------------------------------------------------------------------------------------
        Observable.intervalRange(1, 5, 0, 1, TimeUnit.SECONDS)
                .skip(1, TimeUnit.SECONDS)   //过滤地1s发送的数据
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.d(TAG + "skip", "根据事件过滤" + String.valueOf(aLong));
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });


    }

输出如下：

4

5、 take() 操作符

/**
     * ====================== take 操作符===========================
     * 只能接收两个事件
     */
    public static void take() {
        Observable
                .just(1, 2, 3, 4, 5, 6, 7)
                .take(2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG + "skip", String.valueOf(integer));
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG + "skip", "onComplete");
                    }
                });
    }

输出如下：

54

6、takeLast() 操作符 

/**
     * =======================takeLast() 操作符 ======================
     * 
     * 只能接收被观察者发送的最后几个事件
     */

    public static void takeLast() {
        Observable
                .just(1, 2, 3, 4, 5, 6, 7)
                .takeLast(2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG + "skip", String.valueOf(integer));
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG + "skip", "onComplete");
                    }
                });
    }

输出如下：

55

7、elementAt() 操作符


/**
     * ========================elementAt() 操作符 ======================================
     * 
     * 只发射第n项数据.
     *  一个参数和两个参数时：
     *  elementAt(第n项)
     * elementAt(第n项，第N项不存在时默认值)
     * 
     *  n为负数时,报IndexOUtOfBoundExection。为正数但超过发射数据长度不会报异常会使用默认值代替
     */

    public static void elementAt() {

        Observable.range(1, 5)
                .elementAt(6, 10)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "elementAt", String.valueOf(integer));
                    }
                });
    }

输出如下：

56

8、elementAtOrError()操作符

/**
     * ==============elementAtOrError()===================================================
     * 
     * 在elementAtError()的基础上，当出现越界情况(当获取位置的索引>事件序列的长度)，即抛出异常
     */
    public static void elementAtOrError() {
        Observable.range(1, 5)
                .elementAtOrError(6)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "elementAtOrErr", String.valueOf(integer));
                    }
                });
    }

9、ignoreElements() 操作符

 /**
     * ========================ignoreElements() 操作符 ======================================
     * 
     * 不管发射的数据.只希望在它完成时和遇到错误时收到通知
     */
    public static void ignoreElements() {

        Observable
                .range(0, 10)
                .ignoreElements()
                .subscribe(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.d(TAG + "ignoreEles", "完成了");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG + "ignoreEles", "出错了");
                    }
                });
    }

输出如下：

57

10、ofType() 操作符 

/**
     * ========================ofType() 操作符 ======================================
     * 
     * 通过数据的类型过滤数据，只发送指定类型数据。
     * 
     * 以下代码观察者只接收到： 1,2
     */
    public static void ofType() {

        Observable.just("哈哈", 1, "嘻嘻", 2, 3.5)
                .ofType(Integer.class)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "ofType", String.valueOf(integer));
                    }
                });
    }

输出如下：

58

11、throttleFirst()/throttleLast() 操作符

/**
     * ========================throttleFirst()/throttleLast() 操作符 ======================================
     * 
     * throttleFirst() 在某段时间内，只发送该段事件第一次事件
     * 
     * throttleLast()  在某段时间内，只发送该段事件最后一次事件
     */

    public static void throttleFirst() {
        Observable.interval(300, TimeUnit.MILLISECONDS) //每个0.3秒发送一个事件
                .throttleFirst(1, TimeUnit.SECONDS) //只接收每秒内发送的第一个数据
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG + "throttleFirst", String.valueOf(aLong));
                    }
                });
    }

输出如下：

59

12、sample()

/**
     * ===================sample()=================================
     * 
     * 在某段时间内，只发送该段时间内最新(最后)1次事件
     * 
     * 与throttleLast类似
     */
    public static void sample() {
        Observable.interval(300, TimeUnit.MILLISECONDS) //每个0.3秒发送一个事件
                .sample(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG + "sample", String.valueOf(aLong));
                    }
                });
    }

输出如下：

60

13、firstElement()/lastElement()

/**
     * ========================firstElement()/lastElement()==========================
     * 
     * 选取第一个元素/最后一个元素
     */
    public static void firstElement() {
        Observable.just(1, 2, 3)
                .firstElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "firstElement", String.valueOf(integer));
                    }
                });
    }

输出如下：
61

 public static void lastElement() {
        Observable
                .just(1, 2, 3)
                .lastElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "lastElement", String.valueOf(integer));
                    }
                });
    }

输出如下：
62

上面代码地址

RxJava各类型操作符详解如下：

RxJava操作符汇总
RxJava操作符（一） —-创建操作符
RxJava操作符（二）—-转换操作符
RxJava操作符（三）—-合并操作符
RxJava操作符（四）—-功能操作符
RxJava操作符（五） —-过滤操作符
RxJava操作符（六）—-条件操作符

zeng_ke
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava2-Samples-master_ThisIsIt_rxjava-samples_
09-30
在RxJava中，数据可以被视为一种流，可以通过一系列操作符进行转换和处理，这些操作符允许我们定义如何处理数据流，包括过滤、合并、延迟执行等。 **RxJava2的改进** RxJava2是RxJava的第二个主要版本，相比第一版...
RxJava 过滤操作符 distinct 和 distinctUntilChanged
小牧在一直在学习,在前进的道路上大家一起学习，进步。
12-02 5305
distinct 看下文档 distinct : 过滤掉重复的元素 distinctUntilChanged: 过滤掉连续重复的元素,不连续重复的是不过滤 看下代码 1 distinct Observable.just(1,1,2,2,3,3,1,2,3).distinct().subscribe(new Consumer<Integer>() { ...
LiveData源码赏析三 —— 常见问题
m0_62167422的博客
06-27 933
通过postValue()方法更新LiveData数据的时候，可能存在数据丢失的情况。 我们连续调用了postValue()10次，但是结果只有最后一次的数据。 这是因为postValue()方法内部其实是将数据回调的逻辑放到了Runnable中，再post给Handler，利用Handler在主线程中更新，因此从postValue()到执行Runnable，中间是存在时间差的。在这段时间内通过postValue()方法更新数据仅仅会改变LiveData内部的值，而不会再次post一个新的Runnable。
RXJS中的操作符distinctUntilChanged
Tonghanhan的博客
04-10 465
返回一个 Observable，它发出源 Observable 发出的所有项目，这些项目与上一个项目相比是不同的。
RxSwift 操作符 (distinctUntilChanged)
Hellolad的博客
05-16 3541
distinctUntilChanged ReactiveX: The Distinct operator filters an Observable by only allowing items through that have not already been emitted. 移除相邻两个相同的元素。 pb1 .distinctUntilChanged() ...
java 2%3等于多少,RxJava 学习笔记（七） --- Filtering 过滤操作
weixin_39744316的博客
03-10 511
1. Filter —> 只发射通过了谓词测试的数据项Filter操作符使用你指定的一个谓词函数测试数据项，只有通过测试的数据才会被发射。示例代码Observable.just(1, 2, 3, 4, 5).filter(new Func1() {@Overridepublic Boolean call(Integer item) {return( item < 4 );}})....
RxJava3-Android-示例：RxJava 3 Android示例-从RxJava 2迁移到RxJava 3-如何在Android中使用RxJava 3
02-04
- **Utils**：可能包含一些 RxJava 3 相关的工具函数，如转换、过滤等操作符的封装。 - **Observables**：定义了特定的数据流，可以是模拟的或者从外部API获取的。 - **Schedulers**：配置和使用不同类型的调度器。 ...
RxJava 操作符 图片
03-31
在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成部分，它们提供了丰富的功能来创建、转换、过滤和组合数据流。 首先，我们来了解一下什么是操作符。在 RxJava 中，操作符是用于...
RxJava操作符
07-01
3. **过滤操作符** - `filter()`: 只允许那些满足特定条件的项通过。 - `skip()`: 忽略Observable发射的前n个项。 - `take()`: 只获取Observable发射的前n个项。 4. **组合操作符** - `merge()`: 合并多个...
RxJava操作符 debounce 和 distinctUntilChanged
Pizza_Lawson的专栏
05-23 4183
1 debounce操作符是用来防重复数据的或者(防抖动)： public final Observable debounce(long timeout, TimeUnit unit) { return debounce(timeout, unit, Schedulers.computation()); } 可以看出只需要传入防抖时间就可以了，比如debounce(200
Jetpack篇——LiveData扩展之Transformations
catzifeng的博客
08-24 4362
文章目录一、简单介绍二、map1、普通实现2、转换类型3、Kotlin 扩展4、源码分析三、switchMap1、普通实现2、对比 Map3、Kotlin 扩展4、源码分析四、distinctUntilChanged1、普通实现2、Kotlin 扩展3、源码分析五、小结 一、简单介绍 Transformations 类是 LiveData 的一个功能扩展类，其是一个私有化构造方法的工具类，且只提供 3 个方法使用，虽然数量不多，但胜在实用，这三个方法分别是： map switchMap distinctU
RxJava 常用操作符大全（二）
花前月下的细说__AndJun
11-16 1441
ThrottleFirst巧妙使用防止View被连续点击，仅发送指定时间段内的第一个信号RxView.clicks(btThrottleFirst) .throttleFirst(3, TimeUnit.SECONDS) .subscribe(new Action1<Void>() { @Override public void call(Void aVoid) { Toast.makeText(m
RxJava3 过滤型操作符
bigfc的博客
11-19 479
通过具体的示例，学习RxJava3 过滤型操作符的用法~
RxJava操作符之过滤操作符(五)
LeiHolmes的博客
10-17 441
上一篇文章我们学习了转换类操作符，本篇我们将一起来学习RxJava过滤类操作符。过滤操作符主要是用来对事件数据进行过滤与筛选，只返回满足条件的数据，一起来看下都有哪些
【Jetpack】LiveData一些容易被忽视的功能
m0_56255097的博客
05-20 521
前言 LiveData平时经常使用，但是仅限于在页面上oberver注册一个观察者，在ViewModel里调用一下setValue、postValue仅此而已，今天决定过一遍LiveData库，发现了几个不常用但是却很有用的东西。 LiveData核心库有两个：lifecycle-livedata和lifecycle-livedata-core LiveData.java 这是LiveData的核心类，所有主要逻辑均位于此 在这里发现了这个observeForever，这个方法很少用，调用此方法注册的观察
RxJava2 / RxAndroid2操作符distinct与distinctUntilChanged去重结果异同
Zhang Phil
05-18 2357
RxJava2 / RxAndroid2操作符distinct与distinctUntilChanged去重结果异同代码例如：package zhangphil.app; import android.os.Bundle; import android.support.annotation.Nullable; import android.support.v7.app.AppCompatActi
RxJava操作符汇总
chuyouyinghe的专栏
02-07 5819
RxJava操作符包含的操作符类型有如下几种： 1、创建操作符 ：创建被观察者（Observable）对象&发送事件 转自：RxJava操作符汇总_zengke的博客-CSDN博客_rxjava操作符 https://blog.csdn.net/zengke1993/article/details/80388510 ...
04.UniRx序列（DistinctUntilChanged、RepeatUntilDestroy、RepeatUntilDisable、SkipUntil、TakeUntil...）
Unity3d 攻城师一枚
11-10 1427
内容包括 DistinctUntilChanged RepeatUntilDestroy RepeatUntilDisable SkipUntil TakeUntil TakeUntilDestroy TakeUntilDisable DistinctUntilChanged Distinct 计算机专业词汇意思是去除重复，翻译过来是 去除重复的数据直到有变化才会通知 监控数据源有没有变化，一...
RxJava操作符入门
最新发布
肇秋贰拾捌的博客
05-16 954
【代码】RxJava操作符入门。
RxJava1中文文档： Observables与操作符解析
RxJava的核心概念是Observable（可观察者）和Observer（观察者），它们之间通过一系列的操作符进行数据流的处理。 1. **Observables（可观察者）** 可观察者是RxJava中的核心组件，它可以发出一系列的数据项或一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值