RX操作符之过滤操作二(firstOrDefault、single、elementAt、sample、throttleFirst、throwttleLast、throttleWithTimeout)

最新推荐文章于 2024-04-26 14:46:14 发布
最新推荐文章于 2024-04-26 14:46:14 发布
阅读量3k 收藏 1
点赞数
分类专栏： RX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nicolelili1/article/details/52116931
版权

一、firstOrDefault

传递一个谓词函数给firstOrDefault，然后发射这个函数判定为true的第一项数据，如果没有数据通过了谓词测试就发射一个默认值。

 Integer[]items = {6,7,81,2,3,4,5};
        Observable myObservable = Observable.from(items)
                .firstOrDefault(88, new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer >85;
                    }
                });
        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                System.out.println("onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                System.out.println("onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError....................");
            }
        };

        myObservable.subscribe(mySubscriber);
运行结果：

二、takeFirst

takeFirst与first类似，除了这一点：如果原始Observable没有发射任何满足条件的数据，first会抛出一个NoSuchElementException，takeFist会返回一个空的Observable（不调用onNext()但是会调用onCompleted）。

三、single

如果是无参的函数，发射多个observable则会抛出异常，执行onError()方法，如果只发射一个值会正常执行。

1.正常执行：

Integer[]items = {6};
        Observable myObservable = Observable.from(items)
                .single();
        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                System.out.println("onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                System.out.println("onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError....................");
            }
        };

        myObservable.subscribe(mySubscriber);


运行结果：


2.运行出错：

 Integer[]items = {6,7,81,2,3,4,5};                    
        Observable myObservable = Observable.from(items)
                .single();
        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                System.out.println("onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                System.out.println("onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError....................");
            }
        };

        myObservable.subscribe(mySubscriber);

运行结果：

四、elementAt

只发射第N项数据，ElementAt操作符获取原始Observable发射的数据序列指定索引位置的数据项，然后当做自己的唯一数据发射。

Integer[]items = {6,7,81,2,3,4,5};
        Observable myObservable = Observable.from(items)
                .elementAt(5);
        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                System.out.println("onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                System.out.println("onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError....................");
            }
        };

        myObservable.subscribe(mySubscriber);
运行结果：



五、elementAtOrDefault

elementAtOrDefault操作符与elementAt的区别是，如果索引值大于数据项数，它会发射一个默认值（通过额外的参数指定），而不是抛出异常。但是如果你传递一个负数索引值，它仍然会抛出一个IndexOutOfBoundsException异常。

六、sample

定期发射Observable最近发射的数据项，Sample操作符定时查看一个Observable，然后发射自上次采样以来它最近发射的数据。

 Integer[]items = {6,7,81,2,3,4,5};

        Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for(int i=0;i<5;i++){
                    subscriber.onNext(i);
                    try{
                        Thread.sleep(1000);
                    }catch (Exception e){

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                System.out.println("onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                System.out.println("onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError....................");
            }
        };

        myObservable.sample(3,TimeUnit.SECONDS).subscribe(mySubscriber);


运行结果：
代码中每隔1s发射一次数据，共5次，订阅时3s订阅一次，于是只取出了第3s发射的数据的值2



七、throttleFirst


throttleFirst与throttleLast/sample不同，在每个采样周期内，它总是发射原始Observable的第一项数据，而不是最近的一项。

        Integer[]items = {6,7,81,2,3,4,5};

        Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for(int i=0;i<5;i++){
                    subscriber.onNext(i);
                    try{
                        Thread.sleep(1000);
                    }catch (Exception e){

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.throttleFirst(2, TimeUnit.SECONDS).subscribe(mySubscriber);

运行结果：


八、throwttleLast

throttleFirst在每个采样周期内，它总是发射原始Observable的最后一项数据，而不是最近的一项。

Integer[]items = {6,7,81,2,3,4,5};

        Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for(int i=0;i<5;i++){
                    subscriber.onNext(i);
                    try{
                        Thread.sleep(1000);
                    }catch (Exception e){

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.throttleLast(2, TimeUnit.SECONDS).subscribe(mySubscriber);

运行结果：


九、throttleWithTimeout

根据指定的时间间隔进行限流，时间单位通过TimeUnit参数指定。这种操作符默认在computation调度器上执行，但是你可以通过第三个参数指定。

 Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(i);
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.throttleWithTimeout(2, TimeUnit.SECONDS).subscribe(mySubscriber);
    }

    private void testThrottleLast() {
        Integer[]items = {6,7,81,2,3,4,5};

        Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for(int i=0;i<5;i++){
                    subscriber.onNext(i);
                    try{
                        Thread.sleep(1000);
                    }catch (Exception e){

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.throttleLast(2, TimeUnit.SECONDS).subscribe(mySubscriber);

运行结果：


十、timeout

对原始Observable的一个镜像，如果过了一个指定的时长仍没有发射数据，它会发一个错误通知

 Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(i);
                    try {
                        Thread.sleep(100*i);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.timeout(300, TimeUnit.MILLISECONDS).subscribe(mySubscriber);

运行结果：



十一、distinct

抑制（过滤掉）重复的数据项

 Integer[]items = {6,6,6,6,7,8,2,2,2,3,4,5};

        Observable<Integer> myObservable =  Observable.from(items);

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.distinct().subscribe(mySubscriber);

运行结果：



十二、distinctUntilChanged

过滤掉连续重复的数据

 Integer[]items = {6,6,5,6,6,7,8,2,2,2,3,4,5};

        Observable<Integer> myObservable =  Observable.from(items);

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.distinctUntilChanged().subscribe(mySubscriber);

运行结果：



十三、ignoreElements

IgnoreElements操作符抑制原始Observable发射的所有数据，只允许它的终止通知（onError或onCompleted）通过。

如果你不关心一个Observable发射的数据，但是希望在它完成时或遇到错误终止时收到通知，你可以对Observable使用ignoreElements操作符，它会确保永远不会调用观察者的onNext()方法。

 Observable<Integer> myObservable =  Observable.create(new Observable.OnSubscribe<Integer>() {

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    subscriber.onNext(i);
                    try {
                        Thread.sleep(100*i);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<Integer> mySubscriber =new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG,"onNext................."+integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        myObservable.ignoreElements().subscribe(mySubscriber);

运行结果：



nicolelili1
关注
专栏目录
Linq查询系列操作符详解（例如First、FirstOrDefault、Any、Contains等）
谁为拨动染血的时空苍穹
11-25 734
介绍 ·First - 返回集合中的第一个元素；不延迟 ·FirstOrDefault - 返回集合中的第一个元素（如果没有则返回默认值）；不延迟 ·Last - 返回集合中的最后一个元素；不延迟 ·LastOrDefault - 返回集合中的最后一个元素（如果没有则返回默认值） ·ElementAt - 返回集合中指定索引的元素；不延迟 ·ElementAtOrDefault - 返回集合中指定索引的元素（如果没有则返回默认值）；不延迟 ·Conta
RxJava3.x入门(四)——过滤操作符
AthonyDavis的博客
07-30 409
RxJava3.x入门指南(二)——过滤操作符 一、根据指定事件条件过滤事件 1.filter() 作用：通过一定逻辑来过滤被观察者发送的事件，如果返回true则发送事件，否则不会发送 代码演示： Observable .just(1,2,3,4,5) .filter(new Predicate<Integer>() { @Override
rxjava ： 过滤操作符 ： throttleFirst、sample/throwttleLast、throttleWithTimeout/debounce
火星男孩的分享空间
09-30 1436
参考： RxJava 1.x 笔记：过滤型操作符 RxJava----操作符：过滤操作符 目录： throttleWithTimeout 和 debounce throttleLast 和 sample throttleWithTimeout 和 debounce 每产生一个数据后，如果在规定的间隔时间内没有别的数据产生，就会发射这个数据，否则忽略该数据。 throttleWithTimeout ...
RxJava debounce()和throttleWithTimeout()
小牧在一直在学习,在前进的道路上大家一起学习，进步。
11-29 1116
官方地址:http://reactivex.io/documentation/operators/debounce.html debounce :防抖动 throttleWithTimeout:节流超时 debounce 和throttleWithTimeout 点击查看详情都跳转到同一个界面 作用大致一样, 但是看源码debounce return 返回值多一个线程 看源码 deb...
RxJava 过滤操作符 throttleFirst 与 throttleLast 以及 sample
小牧在一直在学习,在前进的道路上大家一起学习，进步。
12-02 4767
看文档发现throttleFirst 与 throttleLast 以及 Sample 都跳到同一个界面Sample throttleFirst :在某段时间内，只发送该段时间内第1次事件(假如一个按钮1秒内点了3次 ,第一次显示,后2次不显示) throttleLast:在某段时间内，只发送该段时间内最后1次事件(假如一个按钮1秒内点了3次 ,最后第一次显示,前两次不显示) ...
java中的first方法_Android 如何实现RxJava中throttleFirst方法
weixin_33571513的博客
02-25 309
概述在指定时间内只执行一次，类似RxJava中的throttleFirst方法，最近在做Android网络监控，发现断网和连上网时，会有回调多次，这样就会导致我们的逻辑被调用多次，不合符需求，本来打算用RxJava中throttleFirst方法做，后来想想还是自己实现，毕竟也不难；具体实现：package com.manbot.rebot.utils;import android.os.Hand...
LINQ标准查询操作符(pdf中文版)---通俗易懂
12-30
### LINQ标准查询操作符详解 #### 一、投影操作符 **1. Select** `Select` 是一种常用的投影操作符，它允许我们基于输入序列中的每个元素创建一个新序列。这种操作通常用来改变序列中元素的数据类型或者提取特定...
Rxjava2操作符大全
04-24
RxJava2的操作符是其核心特性之一，它们允许开发者对数据流进行各种操作和转换。以下为RxJava2中一些常用操作符的详细说明： ### 创建操作符 这些操作符用于创建Observable对象，为数据流提供起点。 - **just()**...
LINQ 的标准查询操作符
06-05
LINQ的核心是它的标准查询操作符库，这些操作符提供了丰富的功能，可以对序列执行各种操作，如过滤、投影、聚合、连接和排序。 **1. LINQ提供程序** - **LINQ to Objects**：用于查询内存中的对象集合，如数组和...
LINQ的标准查询操作符
03-05
LINQ不仅提供了一种新的方式来查询数据，还引入了一个丰富的标准查询操作符库，这些操作符可以用于执行各种各样的数据操作，例如过滤、排序、分组等。 #### 二、标准查询操作符的作用 标准查询操作符是一系列内置的...
Rxjava，ThrottleFirst防止按钮连续点击，防重复，防抖动
张雨的博客
12-04 5464
ThrottleFirst 允许设置一个时间间隔，在这个时间间隔内发送第一个事件，而屏蔽其他事件，在时间间隔达到设置的时间后，发送下一个事件
Rx_java（7）Rx_java2操作符(throttleFirst、debounce )介绍-防止按钮被重复点击案例
D先生的博客
01-08 9500
相关文章 观察者模式实例讲解 使用java中的类（Observable与Observer）实现观察者模式 Rx_java2的基本使用 Rx_java2中的线程控制 Rx_java2操作符介绍1（Map、Flatmap） Rx_java2操作符介绍2(debounce 、filter 、switchMap ) Retrofit结合RxJava2使用 写在前面 本篇将通过一个实例-防止按钮被
RxJava firstElement 与 lastElement 以及 elementAt
小牧在一直在学习,在前进的道路上大家一起学习，进步。
12-02 941
1firstElement 文档如下 2lastElement 文档如下 3elementAt 文档如下 下面写一个下代码 firstElement Observable.just(1,2,3,4,5,6) .firstElement() .subscribe...
Android函数响应式编程——必学的RxJava过滤操作符filter、elementAt、distinct、skip、take、ignoreElements、throttleFirst
qq_36523667的博客
12-09 1156
之前采用的都是分开的写法，现在想想还是写在一起好。 1.filter：例子中就是过滤大于2的 rx.Observable.just(1,2,3,4).filter(new Func1, Boolean>() { @Override public Boolean call(Integer integer) { return integer > 2;
android 功能防抖,Android RxJava 实战系列：功能防抖
weixin_31473011的博客
05-25 279
前言Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。Github截图RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求今天，我将为大家带来 Rxjava创建操作符的常见开发应用场景：功能防抖需求 ，并结合Retrofit与RxJava 实现，希望大家会喜欢。本系列文章主要基于 ...
Rxjava的学习之过滤操作符—first
源代码的博客
05-10 879
first() first(Func1) firstOrDefault(T) firstOrDefault(T, Func1) takeFirst(Func1) 1.first() Integer[] ints={1,2,3,4}; Observable.from(ints) .first().subscribe(new Subscriber() { @
Rxjava2 Observable的数据过滤详解及实例（一）
JiangMing-JIM的博客
12-30 739
文章目录简要：1. Debounce1.1 debounce(timeout, unit)1.2 debounce(debounceSelector)2. Throttle2.1 throttleFirst(windowDuration, unit)2.2 throttleLast(intervalDuration, unit)2.3 throttleWithTimeout(timeout, u...
Rxjava之throttleLast操作符
最新发布
qx102的博客
04-26 896
当上游数据发送太快，可以使用throttleLast操作符来降频，使得下游可以在一个固定时间内接收最后一条数据，抛弃中间已过时的数据。
高可用之——节流
冰河的专栏
09-12 814
在特定时间窗口内对重复的相同事件最多只处理一次，或者需要限制多个连续相同事件的最小执行时间间隔，可以使用节流（Throttle）实现，可以防止多个相同事件连续重复执行。节流主要的用法有：throttleFirst、throttleLast、throttleWithTimeout。 一、throttleFirst/throttleLast throttleFirst/throttleLast指的...
LINQ查询操作符详解：过滤、排序、联接与更多
"LINQ标准查询操作符.pdf" LINQ（Language Integrated Query，语言集成查询）是.NET Framework的一部分，它为.NET编程语言（如C#和VB.NET）提供了内置的查询支持，使得数据查询如同操作本地集合一样简单。LINQ的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值