Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1226731
  • 博文数量: 114
  • 博客积分: 3526
  • 博客等级: 中校
  • 技术积分: 1825
  • 用 户 组: 普通用户
  • 注册时间: 2009-09-08 09:46
  • 认证徽章:
个人简介

记录总结自己的工作

文章分类

全部博文(114)

文章存档

2015年(19)

2014年(10)

2013年(6)

2012年(17)

2011年(24)

2010年(21)

2009年(17)

分类: Android平台

2015-09-28 17:28:09

    在这篇文章里我们来了解一下条件和布尔操作符。

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

    Amb操作符可以将至多9个Observable结合起来,让他们竞争。哪个Observable首先发射了数据(包括onError和onComplete)就会继续发射这个Observable的数据,其他的Observable所发射的数据都会别丢弃。

    下面使用这两个操作符,对于all操作符我们做了这样的限制,初次使用的时候tag为false,会创建6个数字的Observable,以后都会创建5个数字的Observable。

点击(此处)折叠或打开

  1. private Observable<Boolean> allObserver() {
  2.         Observable<Integer> just;
  3.         if (tag) {
  4.             just = Observable.just(1, 2, 3, 4, 5);
  5.         } else {
  6.             just = Observable.just(1, 2, 3, 4, 5, 6);
  7.         }
  8.         tag = true;
  9.         return just.all(integer -> integer < 6);
  10.     }

  11.     private Observable<Integer> ambObserver() {
  12.         Observable<Integer> delay3 = Observable.just(1, 2, 3).delay(3000, TimeUnit.MILLISECONDS);
  13.         Observable<Integer> delay2 = Observable.just(4, 5, 6).delay(2000, TimeUnit.MILLISECONDS);
  14.         Observable<Integer> delay1 = Observable.just(7, 8, 9).delay(1000, TimeUnit.MILLISECONDS);
  15.         return Observable.amb(delay1, delay2, delay3);
  16.     }
    分别进订阅

点击(此处)折叠或打开

  1. mLButton.setText("all");
  2. mLButton.setOnClickListener(e -> allObserver().subscribe(i -> log("all:" + i)));
  3. mRButton.setText("amb");
  4. mRButton.setOnClickListener(e -> ambObserver().subscribe(i -> log("amb:" + i)));
    运行结果如下所示。第一次返回的6个数据的Observable不满足所有都小于6的条件,所以结果是false,以后的都满足条件,所以结果是true。使用amb操作符的Observable,第一个发射的数据的是7,所以输出了7,8,9,其他的数据都丢弃了。


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

    用这两个操作符来判断一下两个Observable对象是否包含某个数据及是否为空

点击(此处)折叠或打开

  1. private Observable<Boolean> containsObserver() {
  2.         if (tag) {
  3.             return Observable.just(1, 2, 3).contains(3);
  4.         }
  5.         tag = true;
  6.         return Observable.just(1, 2, 3).contains(4);
  7.     }

  8.     private Observable<Boolean> defaultObserver() {
  9.         return Observable.create(new Observable.OnSubscribe<Integer>() {
  10.             @Override
  11.             public void call(Subscriber<? super Integer> subscriber) {
  12.                 subscriber.onCompleted();
  13.             }
  14.         }).isEmpty();
  15.     }
    分别进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("contains");
  2. mLButton.setOnClickListener(e -> containsObserver().subscribe(i -> log("contains:" + i)));
  3. mRButton.setText("isEmpty");
  4. mRButton.setOnClickListener(e -> defaultObserver().subscribe(i -> log("isEmpty:" + i)));
    运行结果如下


    三、DefaultIfEmpty
    DefaultIfEmpty操作符会判断源Observable是否发射数据,如果源Observable发射了数据则正常发射这些数据,如果没有则发射一个默认的数据

    下面我们用这个操作符来处理一个空的和一个非空的Observable,如果为空的话就返回默认值10

点击(此处)折叠或打开

  1. private Observable<Integer> emptyObserver() {
  2.         return Observable.create(new Observable.OnSubscribe<Integer>() {
  3.             @Override
  4.             public void call(Subscriber<? super Integer> subscriber) {
  5.                 subscriber.onCompleted();
  6.             }
  7.         }).defaultIfEmpty(10);
  8.     }

  9.     private Observable<Integer> notEmptyObserver() {
  10.         return Observable.create(new Observable.OnSubscribe<Integer>() {
  11.             @Override
  12.             public void call(Subscriber<? super Integer> subscriber) {
  13.                 subscriber.onNext(1);
  14.                 subscriber.onCompleted();
  15.             }
  16.         }).defaultIfEmpty(10);
  17.     }
    分别进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("empty");
  2. mLButton.setOnClickListener(e -> emptyObserver().subscribe(i -> log("empty:" + i)));
  3. mRButton.setText("notEmpty");
  4. mRButton.setOnClickListener(e -> notEmptyObserver().subscribe(i -> log("notEmpty:" + i)));
    运行结果如下
    

    四、SequenceEqual
    SequenceEqual操作符用来判断两个Observable发射的数据序列是否相同(发射的数据相同,数据的序列相同,结束的状态相同),如果相同返回true,否则返回false

    下面用SequenceEqual分别来判断两个相同的和不相同的Observable

点击(此处)折叠或打开

  1. private Observable<Boolean> equalObserver() {
  2.         return Observable.sequenceEqual(Observable.just(1, 2, 3), Observable.just(1, 2, 3));
  3.     }

  4.     private Observable<Boolean> notEqualObserver() {
  5.         return Observable.sequenceEqual(Observable.just(1, 2, 3), Observable.just(1, 2));
  6.     }
    分别进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("equal");
  2. mLButton.setOnClickListener(e -> equalObserver().subscribe(i -> log("equal:" + i)));
  3. mRButton.setText("notequal");
  4. mRButton.setOnClickListener(e -> notEqualObserver().subscribe(i -> log("notequal:" + i)));
    运行结果如下


    五、SkipUntil、SkipWhile
    这两个操作符都是根据条件来跳过一些数据,不同之处在于SkipUnitl是根据一个标志Observable来判断的,当这个标志Observable没有发射数据的时候,所有源Observable发射的数据都会被跳过;当标志Observable发射了一个数据,则开始正常地发射数据。SkipWhile则是根据一个函数来判断是否跳过数据,当函数返回值为true的时候则一直跳过源Observable发射的数据;当函数返回false的时候则开始正常发射数据。

    下面使用这两个操作符来跳过一些数据项。

点击(此处)折叠或打开

  1. private Observable<Long> skipUntilObserver() {
  2.         return Observable.interval(1, TimeUnit.SECONDS).skipUntil(Observable.timer(3, TimeUnit.SECONDS));
  3.     }

  4.     private Observable<Long> skipWhileObserver() {
  5.         return Observable.interval(1, TimeUnit.SECONDS).skipWhile(aLong -> aLong < 5);
  6.     }
    分别进行订阅

点击(此处)折叠或打开

  1. mLButton.setText("skipUntil");
  2. mLButton.setOnClickListener(e -> skipUntilObserver().subscribe(i -> log("skipUntil:" + i)));
  3. mRButton.setText("skipWhile");
  4. mRButton.setOnClickListener(e -> skipWhileObserver().subscribe(i -> log("skipWhile:" + i)));
    运行结果如下

    
    六、TakeUntil、TakeWhile
    TakeUntil和TakeWhile操作符可以说和SkipUnitl和SkipWhile操作符是完全相反的功能。TakeUntil也是使用一个标志Observable是否发射数据来判断,当标志Observable没有发射数据时,正常发射数据,而一旦标志Observable发射过了数据则后面的数据都会被丢弃。TakeWhile则是根据一个函数来判断是否发射数据,当函数返回值为true的时候正常发射数据;当函数返回false的时候丢弃所有后面的数据。


    下面使用这两个操作符来take两个Observable发射的数据

点击(此处)折叠或打开

  1. private Observable<Long> takeUntilObserver() {
  2.         return Observable.interval(1, TimeUnit.SECONDS).takeUntil(Observable.timer(3, TimeUnit.SECONDS));
  3.     }

  4.     private Observable<Long> takeWhileObserver() {
  5.         return Observable.interval(1, TimeUnit.SECONDS).takeWhile(aLong -> aLong < 5);
  6.     }
    分别进行订阅
    

点击(此处)折叠或打开

  1. mLButton.setText("takeUntil");
  2. mLButton.setOnClickListener(e -> takeUntilObserver().subscribe(i -> log("takeUntil:" + i)));
  3. mRButton.setText("takeWhile");
  4. mRButton.setOnClickListener(e -> takeWhileObserver().subscribe(i -> log("takeWhile:" + i)));
    运行结果如下


    关于条件和布尔操作符就到这了,本文中所有的demo程序见:https://github.com/Chaoba/RxJavaDemo

阅读(5920) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册