初识RxJava（五）过滤类操作符

最新推荐文章于 2024-05-22 16:28:54 发布

码虫韩小怂

最新推荐文章于 2024-05-22 16:28:54 发布

阅读量335

点赞数

分类专栏： RxJava 使用

版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.youkuaiyun.com/xiangshiweiyu_hd/article/details/83925119

版权

RxJava 使用专栏收录该内容

7 篇文章

订阅专栏

本文详细介绍了RxJava中的多种过滤操作符，包括filter、ofType、skip、distinct、take、throttleFirst等，通过具体代码示例展示了每个操作符的作用及效果，帮助读者深入理解并掌握RxJava数据流的过滤技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言：

前面已经记录了四种操作符，分别是创建、延时、转换、组合操作符，每天闲来无事看一篇。找个时间写个demo 敲一下，然后就大体记住了，会用的第一步是记住，记住的第一步是认识。下面开始过滤操作符的笔记记录；

正文：

1、filter 操作符

1)、作用

从被观察者内过滤掉不符合需求条件的内容，将符合条件的内容发射给观察者；

2)、代码

 /**
     * filter 操作符
     */
    private void filterMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 4;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                logDUtils("onNext:" + integer);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("onComplete");
            }
        });
    }

3)、效果

2、ofType 操作符

1)、作用

用于过滤被观察者发送的数据得到指定类型数据，将筛选后的数据在观察者那里进行接收；

2)、代码

 /**
     * ofType 操作符
     */
    private void ofTypeMethod() {
        Observable.just(1, "Android", "Java", 4, "航展")
                .ofType(String.class).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("onSubscribe");
            }

            @Override
            public void onNext(String s) {
                logDUtils("onNext:" + s);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("onComplete");
            }
        });
    }

3)、效果

3、skip 操作符和 skipLast 操作符

1)、作用

skip：跳过发射事件的前 n 个数据；
skipLast ：跳过发射事件的后 n 个数据。

2)、代码

  /**
     * skip 操作符 和 skipLast 操作符
     */
    @SuppressLint("CheckResult")
    private void skipMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8).skip(2).skipLast(3)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        logDUtils("accept:" +integer);
                    }
                });
    }

3)、效果

4、distinct 操作符和 distinctUntilChanged 操作符

1)、作用

distinct ：过滤重复的事件

distinctUntilChanged ：过滤连续重复事件

2)、代码

  /**
     * distinct 操作符 和  distinctUntilChanged 操作符
     */

    @SuppressLint("CheckResult")
    private void distinctMethod() {
        Observable.just(1, 22, 33, 44, 55, 33, 1, 22).distinct().subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                logDUtils("distinct--->accept:" + integer);
            }
        });

        Observable.just(1, 1, 2, 3, 4, 4, 5, 6, 6,5).distinctUntilChanged().subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                logDUtils("distinctUntilChanged--->accept:" + integer);
            }
        });
    }

3)、效果

5、take 操作符和 takeLast 操作符

1)、作用

take ：只获取被观察者发送的数据的前几位数据
takeLast ：只获取被观察发送的数据的后几位数据

2)、代码

  /**
     * take 操作符 和 takeLast 操作符
     */
    @SuppressLint("CheckResult")
    private void takeMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).take(3).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("take--->onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                logDUtils("take--->onNext:" + integer);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("take--->onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("take--->onComplete");
            }
        });


        Observable.just(1, 2, 3, 4, 5, 6, 78, 9).takeLast(4).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("takeLast--->onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                logDUtils("takeLast--->onNext:" + integer);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("takeLast--->onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("takeLast--->onComplete");
            }
        });
    }

3)、效果

6、throttleFirst 操作符和 throttleLast 操作符

1)、作用

throttleFirst ：规定事件内只发送这段时间内的第 1 次数据
throttleLast ：规定事件内只发送这段时间内的最后 1 次数据

2)、代码


    /**
     * throttleFirst 操作符 和 throttleLast 操作符
     */
    @SuppressLint("CheckResult")
    private void throttleFirstAndThrottleLastMethod() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("a");
                Thread.sleep(400);
                emitter.onNext("b");
                Thread.sleep(400);
                emitter.onNext("c");
                Thread.sleep(400);
                emitter.onNext("d");
                Thread.sleep(400);
                emitter.onNext("e");
                Thread.sleep(400);
                emitter.onNext("f");
            }
        }).throttleFirst(2, TimeUnit.SECONDS).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                logDUtils("throttleFirst--->accept:" + s);
            }
        });

        // interval 操作符： 从 0 开始 每隔 100 毫秒 产生一个递增的 long 类型数据
        Observable.interval(100, TimeUnit.MILLISECONDS)
                .throttleLast(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        logDUtils("throttleLast---->accept:" + aLong);
                    }
                });
    }

3)、效果

7、Sample 操作符

作用

在某段时间内，只发送该段时间内最新即最后一次 1次事件类似于 throttleLast 操作符

8、throttleWithTimeout 操作符和 debounce 操作符

1)、作用

只发射给观察者的规定时间内最后一个数据。

2)、代码

  /**
     * debounce 操作符 和 throttleWithTimeout 操作符
     */
    @SuppressLint("CheckResult")
    private void debounceAndThrottleWithTimeoutMethod() {
        //intervalRange : 开始数字为 1 数字数量为90 初始延迟1毫秒 数字间隔为100毫秒
        Observable.intervalRange(1,90,1,100, TimeUnit.MILLISECONDS)
                .debounce(101, TimeUnit.MILLISECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        logDUtils("accept:" + aLong);
                    }
                });
    }

3)、效果

8、elementAt 操作符

1)、作用

获取指定索引处的数据

2)、代码

  /**
     * elementAt  操作符
     */
    @SuppressLint("CheckResult")
    private void elementAtMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).elementAt(4).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                logDUtils("accept:" + integer);
            }
        });
    }

#####3)、效果

注意：初始索引为 0

9、firstElement 操作符和 lastElement 操作符

1)、作用

firstElement ：获取首个数据
lastElement ：获取最后一个数据

2)、代码

  /**
     * firstElement 操作符 和 lastElement 操作符
     */
    @SuppressLint("CheckResult")
    private void firstElementAndLastElementMethod() {
        Observable.just("首个", "a", "b", "c").firstElement().subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                logDUtils("accept:" + s);
            }
        });
    }

3)、效果

10、elementAtOrError操作符

作用

与 elementAt 操作符配合使用，当出现越界的情况抛出异常。

欢迎关注

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

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