RxJava 现学现用中（操作符）

最新推荐文章于 2021-05-27 02:03:36 发布

Day_Day_Up 1024

最新推荐文章于 2021-05-27 02:03:36 发布

阅读量133

点赞数

分类专栏：开源框架 RxJava 文章标签： android

本文链接：https://blog.csdn.net/sinat_41268473/article/details/108551071

版权

开源框架同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

RxJava

3 篇文章 1 订阅

订阅专栏

接上篇，还剩过滤性操作符和条件布尔操作符未讲。

过滤性操作符

过滤性操作符：按照一定的条件过滤事件，主要包括以下几类：

条件过滤操作符

1.Filter()

过滤指定条件的事件

        Observable.just(1, 2, 3, 4, 5)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 3;
                    }

                    // a. 返回true，则继续发送
                    // b. 返回false，则不发送（即过滤）

                }).subscribe(new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer value) {
//                Log.d(TAG, "过滤后得到的事件是：" + value);
            }

            @Override
            public void onError(Throwable e) {
//                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
//                Log.d(TAG, "对onComplete事件作出响应");
            }
        });

2.ofType()

过滤特定类型的数据

 Observable.just(1, "hello", 3, "world", 5)
                .ofType(String.class) // 筛选出 整型数据
                .subscribe(new Consumer<String>() {

                    @Override
                    public void accept(String s) throws Exception {
                        Log.d(TAG, "过滤后得到的事件是：" + s);
                    }
                });

3.skip()/skipLast()

跳过某个事件

Observable.just(1, 2, 3, 4, 5)
                .skip(2) // 跳过正序前两项
                .skipLast(2) // 跳过倒序后两项
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "过滤后得到的事件是：" + integer);
                    }
                });

4.distinct() / distinctUntilChange()

过滤重复/连续重复事件

        Observable.just(1, 3, 4, 4, 3, 2)
                .distinct()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "过滤重复的事件：" + integer);
                    }
                });

执行结果: 1 3 4 2

  Observable.just(1, 3, 4, 4, 3, 3, 2, 5, 5)
                .distinctUntilChanged()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "过滤连续重复的事件：" + integer);
                    }
                });

执行结果: 1 3 4 3 2 5

事件数量过滤

1.take()

指定观察者最多能接收到的事件数量

Observable.just(1, 2, 3, 4, 5)
                .take(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "过滤连续得到的事件：" + integer);
                    }
                });

2.takeLast()

指定观察者接收最后几个事件

   Observable.just(1, 2, 3, 4, 5)
                .takeLast(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "过滤连续得到的事件：" + integer);
                    }
                });

指定时间过滤

1.throttleFirst()/throttleLast()

某段时间只接收观察者第一个/最后一个事件

 Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                Thread.sleep(500);
                emitter.onNext(4);
                Thread.sleep(1000);
                emitter.onNext(2);
                Thread.sleep(500);
                emitter.onNext(3);
                Thread.sleep(500);
            }
        }).throttleFirst(2, TimeUnit.SECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "throttleFirst过滤连续得到的事件：" + integer);
                    }
                });

执行结果 1 3

 Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                Thread.sleep(500);
                emitter.onNext(4);
                Thread.sleep(1000);
                emitter.onNext(2);
                Thread.sleep(500);
                emitter.onNext(3);
                Thread.sleep(500);
            }
        }).throttleLast(2, TimeUnit.SECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "throttleLast过滤连续得到的事件：" + integer);
                    }
                });

执行结果 2 3

2.sample()

发送该段事件最后一次事件和throttleLast类似

3.throttleWithTimeOut() / debounce()

发送数据事件时若两次发送的事件时间间隔<小于指定时间就会丢弃前一次的数据直到指定时间间隔没有发送新数据时才发送最后一次数据。

Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1); // 1、4发送事件小于1s 1 抛弃
                Thread.sleep(500);
                emitter.onNext(4);//  发送事件间隔>1s 发送4 然后2 、3发送<1s 2抛弃
                Thread.sleep(1500);
                emitter.onNext(2);// 最后发送3
                Thread.sleep(500);
                emitter.onNext(3);
            }
        }).throttleWithTimeout(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "throttleWithTimeout过滤连续得到的事件：" + integer);
                    }
                });

执行结果：4 3

事件位置过滤

1.firstElement/lastElement

选取第一个元素/最后一个元素

Observable.just(1, 2, 3, 5, 0)
//                .firstElement()
                .lastElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "firstElement过滤连续得到的事件：" + integer);
                    }
                });

执行结果：firstElement() 1/lastElement() 0

2.elementAt() /elementAtOrError()

获取索引位置的元素（允许越界）/索引越界抛异常

        Observable.just(1, 3, 5, 6, 8)
//                .elementAt(2)
                .elementAt(6, 9) // 越界后默认9
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "elementAt过滤连续得到的事件：" + integer);
                    }
                });

执行结果： elementAt() 5/越界 9

 Observable.just(1, 3, 5, 6, 8)
                .elementAtOrError(6)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "elementAt过滤连续得到的事件：" + integer);
                    }
                });

执行结果： elementAtOrError() 抛异常

条件布尔操作符

主要包括：

1.all()

判断发送的每项数据是否都满足条件满足 ture 不满足 false

        Observable.just(1, 2, 3, 4)
                .all(new Predicate<Integer>() {
                   @Override
                    public boolean test(Integer integer) throws Exception {
                        // 发送的数据都<=5 返回true
                       return integer <= 5;
                    }
               }).subscribe(new Consumer<Boolean>() {
           @Override
           public void accept(Boolean result) throws Exception {
               Log.d(TAG, "result :" + result);
           }
        });

2.takeWhile()

判断发送的每项数据是否都满足条件满足发送不满足停止发送

        Observable.interval(1, TimeUnit.SECONDS)
                .takeWhile(new Predicate<Long>() {
                    @Override
                    public boolean test(Long aLong) throws Exception {
                        // <3才开始发送数据
                        return (aLong < 3);
                    }
                }).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "收到onNext事件：" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "收到onError事件：" + e.toString());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "收到onComplete事件");
            }
        });

3.skipWhile()

判断发送的每项数据是否都满足条件不满足开始发送

        Observable.interval(1,TimeUnit.SECONDS)
                .skipWhile(new Predicate<Long>() {
                    @Override
                    public boolean test(Long aLong) throws Exception {
//         >5才开始发送数据
                        return aLong<=5;
                    }
                }).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "收到onNext事件：" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "收到onError事件：" + e.toString());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "收到onComplete事件");
            }
        });

4.takeUntil()

传人的Observable发送数据第一个Observable停止发送数据

        Observable.interval(1, TimeUnit.SECONDS)
                .takeUntil(new Predicate<Long>() {
                    @Override
                    public boolean test(Long aLong) throws Exception {
                        // >3停止发送数据
                        return aLong > 3;
                    }
                }).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "收到onNext事件：" + aLong);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "收到onError事件：" + e.toString());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "收到onComplete事件");
            }
        });

5.skipUntil()

传人的Observable发送数据第一个Observable开始发送数据

        Observable.interval(1, TimeUnit.SECONDS)
                // 传入的Observable发送数据，第一个Observable才发送数据
                .skipUntil(Observable.interval(5,1,TimeUnit.SECONDS))
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.d(TAG, "收到onNext事件：" + aLong);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "收到onError事件：" + e.toString());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "收到onComplete事件");
                    }
                });

6.SequenceEqual()

判断两个Observable发送数据是否相同相同返回true 反之false

        Observable.sequenceEqual(
                Observable.just(1,2,3),
                Observable.just(1,2,3)
        ).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean result) throws Exception {
                Log.d(TAG, "result ：" + result);
            }
        });

7.contains()

判断发送的数据包含指定数据包含true 反之false

Observable.just(1,2,4,7)
                .contains(4)
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean result) throws Exception {
                        Log.d(TAG, "result ：" + result);
                    }
                });

8.isEmpty()

判断发送的数据是否为空若为空返回true 反之false

        Observable.just(1, 2, 4, 7)
                .isEmpty()
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean result) throws Exception {
                        Log.d(TAG, "result ：" + result);
                    }
                });

9.amb()

发送多个Observable，只发送先发送的Observable数据其余丢弃

        List<Observable<Integer>> observableList = new ArrayList<>();
        Observable<Integer> observable1 = Observable.just(1,2,3,4);
        Observable<Integer> observable2 = Observable.just(5,7,8).delay(1,TimeUnit.SECONDS);
        observableList.add(observable1);
        observableList.add(observable2);

        Observable.amb(observableList)
                .subscribe(new Consumer<Integer>() {
                   // 只发送先发送的数据，后发送的舍弃
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "接收的数据 ：" + integer);
                    }
                });

10.defaultIfEmpty()

在不发送next事件下，仅发送一个complete事件的前提下，发送一个默认值

 Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
//                emitter.onNext(1);
//                emitter.onNext(2);
                // 只发送Complete事件
                emitter.onComplete();

            }
        }).defaultIfEmpty(11)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "收到onNext事件：" + integer);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "收到onError事件：" + e.toString());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "收到onComplete事件");
                    }
                });

至此，RxJava所有的操作符介绍完毕了，下篇介绍这些操作符的应用场景。

Thanks：RxJava系列教程

Day_Day_Up 1024

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava 现学现用中（操作符）

接上篇，还剩过滤性操作符和条件布尔操作符未讲。过滤性操作符过滤性操作符：按照一定的条件过滤事件，主要包括以下几类：条件过滤操作符 1.Filter() 过滤指定条件的事件 Observable.just(1, 2, 3, 4, 5) .filter(new Predicate<Integer>() { @Override ...
复制链接

扫一扫

专栏目录