RxJava操作符——条件和布尔操作符(Conditional and Boolean Operators)

RxJava系列教程:

1. RxJava使用介绍 【视频教程】

2. RxJava操作符

? Creating Observables(Observable的创建操作符) 【视频教程】

? Transforming Observables(Observable的转换操作符) 【视频教程】

? Filtering Observables(Observable的过滤操作符) 【视频教程】

? Combining Observables(Observable的组合操作符) 【视频教程】

? Error Handling Operators(Observable的错误处理操作符) 【视频教程】

? Observable Utility Operators(Observable的辅助性操作符) 【视频教程】

? Conditional and Boolean Operators(Observable的条件和布尔操作符) 【视频教程】

? Mathematical and Aggregate Operators(Observable数学运算及聚合操作符) 【视频教程】

? 其他如observable.toList()、observable.connect()、observable.publish()等等; 【视频教程】

3. RxJava Observer与Subcriber的关系 【视频教程】

4. RxJava线程控制(Scheduler) 【视频教程】

5. RxJava 并发之数据流发射太快如何办(背压(Backpressure)) 【视频教程】


All

All操作符根据一个函数对源Observable发射的所有数据进行判断,最终返回的结果就是这个判断结果。这个函数使用发射的数据作为参数,内部判断所有的数据是否满足我们定义好的判断条件,如果全部都满足则返回true,否则就返回false。

示例代码:

Observable.from(studentList).all(new Func1<Student, Boolean>() {

            @Override
            public Boolean call(Student student) {
                return student.age > 25;
            }
        }).subscribe(new Action1<Boolean>() {

            @Override
            public void call(Boolean value) {
                System.out.println("onSuccess value = " + value);
            }
        });

List<Student> studentList = new ArrayList<Student>() {
        {
            add(new Student("Stay", 28));
            add(new Student("谷歌小弟", 23));
            add(new Student("Star", 25));
        }
    };

输出:

onSuccess value = false

Amb

传递两个或多个(至多9个)Observable给Amb时,它只发射其中首先发射数据或通知(onError或onCompleted)的那个Observable的所有数据,而其他所有的Observable的发射物将被丢弃。

有一个类似的对象方法ambWith。Observable.amb(o1,o2)和o1.ambWith(o2)是等价的。

示例代码:

Observable.amb(Observable.just(1,2,3,4,5).delay(2, TimeUnit.SECONDS),
                Observable.just(100,101))
                .subscribe(new Action1<Integer>() {

                    @Override
                    public void call(Integer value) {
                        System.out.println("call value = " + value);
                    }
                });

输出:

call value = 100
call value = 101

Contains、IsEmpty 、exists

Contains操作符用来判断源Observable所发射的数据是否包含某一个数据,如果包含会返回true,如果源Observable已经结束了却还没有发射这个数据则返回false。

IsEmpty:相关的一个操作符IsEmpty用于判定原始Observable是否没有发射任何数据。

exists:RxJava中还有一个exists操作符,它通过一个谓词函数测试原始Observable发射的数据,只要任何一项满足条件就返回一个发射true的Observable,否则返回一个发射false的Observable。

示例代码:

//Contains:判定一个Observable是否发射一个特定的值
Observable.just(4,5,6)
        .contains(4)
        .subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                System.out.println("contains(4):"+aBoolean);
            }
        });
//isEmpty:判定原始Observable是否没有发射任何数据
Observable.just(4,5,6)
        .isEmpty()
        .subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                System.out.println("isEmpty():"+aBoolean));
            }
        });

//exists操作符,它通过一个谓词函数测试原始Observable发射的数据,
// 只要任何一项满足条件就返回一个发射true的Observable,
// 否则返回一个发射false的Observable。
Observable.just(4,5,6)
        .exists(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer<5;
            }
        })
        .subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                System.out.println("exists():"+aBoolean);
            }
        });

输出:

contains(4):true
isEmpty():false
exists():true

DefaultIfEmpty

??DefaultIfEmpty简单的精确地发射原始Observable的值,如果原始Observable没有发射任何数据正常终止(以onCompleted的形式),DefaultIfEmpty返回的Observable就发射一个你提供的默认值。

示例代码:

Observable.empty()
        .defaultIfEmpty(10)
        .subscribe(new Action1<Integer>() {

            @Override
            public void call(Integer value) {
                System.out.println("defaultIfEmpty:" + value);
            }
        });

输出:

defaultIfEmpty:10

SequenceEqual

判定两个Observables是否发射相同的数据序列。 传递两个Observable给SequenceEqual操作符,它会比较两个Observable的发射物,如果两个序列是相同的(相同的数据,相同的顺序,相同的终止状态),它就发射true,否则发射false。

示例代码:

Observable.sequenceEqual(
        //第一个Observable延迟1秒发射数据
        Observable.just(4,5,6).delay(1,TimeUnit.SECONDS),
        Observable.just(4,5,6))
        .subscribe(new Action1<Boolean>() {
            @Override
            public void call(Boolean aBoolean) {
                System.out.println("sequenceEqual:"+aBoolean);
            }
        });
        .subscribe(aBoolean -> Log.v(TAG, "sequenceEqual:"+aBoolean));

输出:

sequenceEqual:true

SkipUntil

SkipUntil订阅原始的Observable,但是忽略它的发射物,直到第二个Observable发射了一项数据那一刻,它开始发射原始Observable。

示例代码:

Observable.interval(1, TimeUnit.SECONDS) //从0开始
        .take(6)
        .skipUntil(Observable.just(10).delay(3,TimeUnit.SECONDS))
        .subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Long value) {
                System.out.println("onNext value = " + value);

            }
        });

输出:

skipUntil value = 3
skipUntil value = 4
skipUntil value = 5

SkipWhile

SkipWhile订阅原始的Observable,但是忽略它的发射物,直到你指定的某个条件变为false的那一刻,它开始发射原始Observable。

示例代码:

Observable.interval(1, TimeUnit.SECONDS) //从0开始
        .take(6)
        .skipWhile(new Func1<Long, Boolean>() {
            @Override
            public Boolean call(Long aLong) {
                return aLong<3;   //舍弃原Observable发射的数据,直到发射的数据>=3,才继续发射
            }
        })
        .subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Long value) {
                System.out.println("skipWhile value = " + value);

            }
        });

输出:

skipWhile value = 3
skipWhile value = 4
skipWhile value = 5

TakeUntil

??takeUntil与skipUntil操作符作用相反,订阅并开始发射原始Observable,它还监视你提供的第二个Observable。如果第二个Observable发射了一项数据或者发射了一个终止通知( onError通知或一个onCompleted通知),TakeUntil返回的Observable会停止发射原始Observable并终止。

示例代码:

Observable.interval(500, TimeUnit.MILLISECONDS) //从0开始
        .takeUntil(Observable.just(100, 101, 102).delay(3, TimeUnit.SECONDS))
        .subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Long value) {
                System.out.println("takeUntil value = " + value);

            }
        });

输出:

takeUntil value = 0
takeUntil value = 1
takeUntil value = 2
takeUntil value = 3
takeUntil value = 4

TakeWhile

takeWhile与skipWhile操作符作用相反,发射原始Observable,直到你指定的某个条件不成立的那一刻,它停止发射原始Observable,并终止自己的Observable。

示例代码:

Observable.interval(1, TimeUnit.SECONDS) //从0开始
        .takeWhile(new Func1<Long, Boolean>() {
            @Override
            public Boolean call(Long aLong) {
                return aLong<3;
            }
        })
        .subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Long value) {
                System.out.println("takeWhile value = " + value);

            }
        });

输出:

takeWhile value = 0
takeWhile value = 1
takeWhile value = 2
时间: 2024-10-05 03:59:06

RxJava操作符——条件和布尔操作符(Conditional and Boolean Operators)的相关文章

Operation之条件和布尔操作符

amb 当传入多个Observable到amb操作符时, 他将取第一个发生元素或产生事件的Observable, 然后只发出他的元素. 并且忽略其他的Observable let subject191 = PublishSubject<Int>() let subject192 = PublishSubject<Int>() let subject193 = PublishSubject<Int>() subject191 .amb(subject192) .amb(s

js中等性操作符(==)、关系操作符(&lt;,&gt;)和布尔操作符(!)比较规则

最近一直在笔试面试,经常碰到例如 123=='123'.'abc'==true等问题,其中有答对的,也有答错的,主要原因还是对ECMAScript的规范没有理解清楚,很多题目没有具体分析所导致.现查阅资料后对此进行一些总结. 等性操作符(==) 1.比较的类型是String.Number.Boolean这几个基本类型时 当是这几中类型进行比较时,会先将两边转换成数字,在进行比较. 1 console.log(1 == true); // true转换成数字为1,因此结果为true 2 3 con

js布尔操作符小记

为了提高学习效率断了下网,没想到这么渣渣网断了之后就连不上了=.=废话少说,开始正题. 重新看红皮书,重点记一下布尔操作符.布尔操作符有 !,&&,||.  一,逻辑非 先说说 !, 非是布尔操作符中唯一一个会把所有数据类型转换为布尔类型的.拿几个特殊值为例: 如果操作数为 null,则 !null返回 true 如果操作数为 undefined,则 !undefined 返回true 如果操作数为 NaN,则 !NaN 返回true 有了 逻辑非,就可以用两个!!来判断一个数据类型的布尔

Javascript 布尔操作符总结

在一门编程语言中,布尔操作符的重要性堪比相等操作符.如果没有测试两个值关系的能力,那么诸如if...else和循环之类的语句就不会有用武之地了.在像javascript这样弱类型语言更有其妙用,让我们的代码,简捷可靠.布尔操作符一共有3个: 与.或.非. 特性: 非 先来讨论一下,最简单的‘非!’ 相对与和或来说,非更简单一点,先把操作数转换为布尔值,再取反,值不是true,就是false. 结论:逻辑非的返回值最后只有两个:true or false.       与和或: 而与和或并不总是返

JS基本概念 -- 操作符 -- 布尔操作符

布尔操作符一共有三个: 非(Not).与(AND).或(OR) 逻辑非逻辑非操作符由一个叹号(!)表示,可以应用于ECMAScript中的任何值.无论这个值是什么类型,这个操作符都会返回一个布尔值.逻辑非操作符首先将他的操作数转换为一个布尔值,再对其求反. //1.如果操作数是一个对象,返回false var o = { name: "ss" }; alert(!o); //false var o1 = {}; alert(!o1); //false //2.如果操作数是一个空字符串,

布尔操作符解析

在一门编程语言中,布尔操作符的重要性堪比相等操作符.如果没有测试两个值关系的能力,那么诸如if...else和循环之类的语句就不会有用武之地了. 布尔操作符一共有3个: 非.与.或 1.逻辑 非 逻辑非用!表示,可以应用与ECMAScript的任何类型的值,逻辑非操作返回的是一个布尔值(true/false).该操作符首先会将它的操作数转换为一个布尔值,然后再对其求反. 下面说明下Boolean()转型函数的一组规则. 数据类型 转换为true的值 转换为false的值 Boolean true

布尔操作符

and . or .not  三个布尔操作符号用于比较布尔值 1.二元布尔操作符 如果两个布尔值都为True, and操作符就将表达式求值为True,否则求值为False:如下: >>> True and True True >>> True and False False >>> 以下为and的操作符的比较: 表达式 求值 True and True True True and False False False and True False Fal

第四十课、前置操作符和后置操作符

一.i++和++i有没有区别? 1.现代编译器产品会对代码进行优化 2.优化使得最终二进制程序更加高效 3.优化后的二进制程序丢失了c/c++的原生语义 4.不可能从编译后的二进制程序还原c/c++程序 //由此可知,单行的i++和++i在汇编层的代码完全一样 int i = 0; 0123136E mov dword ptr [i],0 i++; 01231375 mov eax,dword ptr [i] 01231378 add eax,1 0123137B mov dword ptr [

第40课 前置操作符和后置操作符

1. ++i和i++真的有区别吗? (1)现代编译器会对代码进行优化.对于基础类型,前置++和后置++的汇编代码几乎是一样的,最终效率完全一样. (2)优化使得最终的二进制程序更加高效 (3)优化后的二进制程序丢失了C/C++的原生语义. (4)不可能从编译后的二进制程序还原C/C++程序. int i = 0; 013612FB mov dword ptr [i],0 i++; 01361302 mov eax,dword ptr [i] 01361305 add eax,1 01361308