美文网首页
RxJava 操作符(辅助、布尔、条件、转换)

RxJava 操作符(辅助、布尔、条件、转换)

作者: IT一书生 | 来源:发表于2018-05-31 18:02 被阅读69次

    辅助操作符

    辅助操作符可以帮助我们更方便的管理Observable。

    • delay
      delay 操作符让原Observable在发射数据之前延迟一段时间。
            Observable.just(1, 2, 3)
                    .delay(2, TimeUnit.SECONDS)
                    .subscribe(new Action1<Integer>() {
                        @Override
                        public void call(Integer integer) {
                            Log.e("zpan", " delay = " + integer);
                        }
                    });
    
    • Do
      Do系列的操作符就是为原始Observable的生命周期事件注册一个回调,当Observable的某个事件发生时就会调用这些回调。

    1.doOnNext:只有执行onNext的时候会被调用。
    2.doOnEach:为Observable注册这样一个回调,当Observable每发射一项数据时就会调用它一次,包括onNext,onError,onCompleted。
    3.doOnSubscribe:当观察者订阅Observable时就会被调用。
    4.doOnUnsubscribe:当观察者取消订阅Observable时就会调用;Observable通过onError或者onCompleted结束时,会取消点阅所有的Subscriber。
    5.doOnCompleted:当Observable正常终止调用onCompleted时会被调用。
    6.doOnError:当Observable异常终止调用onError时会被调用。
    7.doOnTerminate:当Observable终止(无论是正常终止还是异常终止)之前会被调用。
    8.finallyDo:当Observable终止(无论是正常终止还是异常终止)之后会被调用。

    doOnNext为例:

            Observable.just(1, 2)
                    .doOnNext(new Action1<Integer>() {
                        @Override
                        public void call(Integer integer) {
                            Log.e("zpan", " doOnNext= " + integer);
                        }
                    })
                    .subscribe(new Subscriber<Integer>() {
                        @Override
                        public void onCompleted() {
                            Log.e("zpan", "======onCompleted======");
                        }
    
                        @Override
                        public void onError(Throwable e) {
                            Log.e("zpan", "======onError======");
                        }
    
                        @Override
                        public void onNext(Integer integer) {
                            Log.e("zpan", " onNext =" + integer);
                        }
                    });
    
    E/zpan:  doOnNext= 1
         onNext =1
         doOnNext= 2
         onNext =2
    E/zpan: ======onCompleted======
    
    • subscribeOn、observeOn
      subscribeOn操作符指定Observable自身在哪个线程上运行。
      observeOn操作符指定observer所运行的线程,也就是发射出的数据在哪个线程上使用。

    • timeOut
      如果原始Observable过了指定的一段时间没有发射任何数据,timeOut 操作符会以一个onError通知终止这个Observable,或继续执行一个备用的Observable。

    布尔操作符

    • all
      all 操作符根据一个函数对原Observable发射的所有数据进行判断,最终返回的结果就是这个判断结果。
            Observable.just(1, 2, 3)
                    .all(new Func1<Integer, Boolean>() {
                        @Override
                        public Boolean call(Integer integer) {
                            Log.e("zpan", " call = " + integer);
                            return integer > 2;
                        }
                    })
                    .subscribe(new Subscriber<Boolean>() {
                        @Override
                        public void onCompleted() {
                            Log.e("zpan", " onCompleted = ");
                        }
    
                        @Override
                        public void onError(Throwable e) {
                            Log.e("zpan", " onError = ");
                        }
    
                        @Override
                        public void onNext(Boolean aBoolean) {
                            Log.e("zpan", " onNext = " + aBoolean);
                        }
                    });
    
    E/zpan:  call = 1
         onNext = false
         onCompleted = 
    

    结论:当有数据不满足条件时,过程也就会停止,结果返回false。

    • contains
      contains 操作符判断原Observable所发射的数据是否包含某一个数据。
    • isEmpty
      isEmpty操作符判断原Observable是否发射过数据。发射过则返回true,否则返回false
            Observable.just(1, 2, 3)
                    .isEmpty()
                    .subscribe(new Action1<Boolean>() {
                        @Override
                        public void call(Boolean aBoolean) {
                            Log.e("zpan", " isEmpty = " + aBoolean);
                        }
                    });
    

    条件操作符

    • amb
      amb 操作符对于给定两个或多个Observable,它只发射首先发射数据或通知的那个Observable。
            Observable.amb(Observable.just(1, 2, 3).delay(2, TimeUnit.SECONDS)
                    , Observable.just(4, 5, 6)).subscribe(new Action1<Integer>() {
                @Override
                public void call(Integer integer) {
                    Log.e("zpan", " amb = " + integer);
                }
            });
    
    E/zpan:  amb = 4
         amb = 5
         amb = 6
    
    • defaultIfEmpty
      如果原Observable没有发射数据,就发射一个默认数据。
            Observable.create(new Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    subscriber.onCompleted();
                }
            }).defaultIfEmpty("默认数据").subscribe(new Action1<String>() {
                @Override
                public void call(String s) {
                    Log.e("zpan", " defaultIfEmpty = " + s);
                }
            });
    
    E/zpan:  defaultIfEmpty = 默认数据
    

    转换操作符

    将Observable转换为另一个对象或数据结构。

    • toList
      toList 操作符将发射多个数据且为每一个数据调用onNext方法的Observable发射的多个数据组合成一个List,然后调用一次onNext方法传递整个列表。
            Observable.just(4,5,6)
                    .toList()
                    .subscribe(new Action1<List<Integer>>() {
                        @Override
                        public void call(List<Integer> integers) {
                            
                        }
                    });
    
    • toSortedList
      toSortedList 操作符类似于toList,不同的是,它会产生的列表排序,默认是自然排序。
            Observable.just(8, 9, 7)
                    .toSortedList()
                    .subscribe(new Action1<List<Integer>>() {
                        @Override
                        public void call(List<Integer> integers) {
                            for (int integer : integers) {
                                Log.e("zpan", " toSortedList = " + integer);
                            }
                        }
                    });
    
    E/zpan:  toSortedList = 7
         toSortedList = 8
         toSortedList = 9
    
    • toMap
      toMap 操作符将原始Observable发射的数据到一个Map,默认是HashMap。
            Observable.just(4, 5, 6)
                    .toMap(new Func1<Integer, String>() {
                        @Override
                        public String call(Integer integer) {
                            return "key - " + integer;
                        }
                    })
                    .subscribe(new Action1<Map<String, Integer>>() {
                        @Override
                        public void call(Map<String, Integer> stringIntegerMap) {
                            Log.e("zpan", " toMap = " + stringIntegerMap.get("key - 5"));
                        }
                    });
    
    E/zpan:  toMap = 5
    

    相关文章

      网友评论

          本文标题:RxJava 操作符(辅助、布尔、条件、转换)

          本文链接:https://www.haomeiwen.com/subject/bqtxsftx.html