RxJava从入门到不离不弃(四)——过滤操作符

RxJava中的过滤操作符,顾名思义,这类操作符主要用于对事件数据的筛选过滤,只返回满足我们条件的数据。

我们试想一下这样的一个需求,有一个学生集合,要求将其中成绩不及格的学生过滤,返回成绩合格的学生集合,如果平时一般会怎么做呢?可能会这样实现:

List<Student> newList = new ArrayList<>();
for (int i = 0; i < oldList.size(); i++) {
    if(oldList.get(i).getCore()>60){
        newList.add(oldList.get(i));
    }
}

对于极度厌恶多层嵌套结构的我来说,实在不喜欢这样的代码。这样的思路,会随着业务逻辑的复杂程度,变得越来越复杂。

还好有RxJava,之后的代码着实简化了许多。

RxJava过滤类操作符主要包含

Filter、Take、TakeLast、TakeUntil、Skip、SkipLast、ElementAt、Debounce、Distinct、DistinctUntilChanged、First、Last等等。

先定义这样一个数据集合:

List<Person> list = new ArrayList<>();
for (int i = 0; i < 20; i++) {
    list.add(new Person(i, "js" + i));
}

filter

filter(Func1)用来过滤观测序列中我们不想要的值,只返回满足条件的值。

filter传入Func1对象,第一个泛型是传入的发射类型,第二个参数是boolean类型,表示是否过滤。

        Observable.from(list)
                .filter(new Func1<Person, Boolean>() {
                    @Override
                    public Boolean call(Person person) {
                        return person.getAge() > 10;
                    }
                })
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("filter", "call: " + person.toString());
                    }
                });

take

take方法,传入一整数n,表示只取前n个数据。

        Observable.from(list)
                .take(3)
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("take", "call: " + person);
                    }
                });

takeLast

takeLast(int)同样用一个整数n作为参数,只不过它发射的是观测序列中后n个元素。

        Observable.from(list)
                .takeLast(3)
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("take", "call: " + person);
                    }
                });

skip

skip(int)让我们可以忽略Observable发射的前n项数据。

        Observable.from(list)
                .skip(3)
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("skip", "call: " + person);
                    }
                });

skipLast

skipLast(int)忽略Observable发射的后n项数据。

        Observable.from(list)
                .skipLast(3)
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("skipLast", "call: " + person);
                    }
                });

elementAt

elementAt(int)用来获取元素Observable发射的事件序列中的第n项数据,并当做唯一的数据发射出去。

        Observable.from(list)
                .elementAt(3)
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("elementAt", "call: " + person);
                    }
                });

first

first()顾名思义,它是的Observable只发送观测序列中的第一个数据项。

        Observable.from(list)
                .first()
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("first", "call: " + person);
                    }
                });

last

last()只发射观测序列中的最后一个数据项。

        Observable.from(list)
                .last()
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("first", "call: " + person);
                    }
                });

distinct

distinct去除重复,有无参形式:

        Observable.just(2, 1, 2, 2, 3, 4, 3, 4, 5, 5)
                .distinct()
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer i) {
                        System.out.print(i + " ");
                    }
                });

还可以传入Func1对象,自己实现判断逻辑:

        list.add(new Person(3, "js3"));
        Observable.from(list)
                .distinct(new Func1<Person, String>() {

                    @Override
                    public String call(Person p) {
                        return p.getName();
                    }
                })
                .subscribe(new Action1<Person>() {
                    @Override
                    public void call(Person person) {
                        Log.e("distinct", "call: " + person);
                    }
                });

debounce

debounce操作符是对源Observable间隔期产生的结果进行过滤,如果在这个规定的间隔期内没有别的结果产生,则将这个结果提交给订阅者,否则忽略该结果,原理有点像光学防抖.

debounce(时间,时间单位)

 Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                try {
                    for (int i = 0; i < 10; i++) {
                        subscriber.onNext(i);
                        try {
                            Thread.currentThread().sleep(i * 1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
                .debounce(5, TimeUnit.SECONDS)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        LogUtils.d("------->call():" + integer);
                    }
                });

最后输出结果是:

03-01 10:01:15.040 3591-3736/com.rxandroid.test1 D/----->: ------->call():5
03-01 10:01:20.030 3591-3736/com.rxandroid.test1 D/----->: ------->call():6
03-01 10:01:26.030 3591-3736/com.rxandroid.test1 D/----->: ------->call():7
03-01 10:01:33.030 3591-3736/com.rxandroid.test1 D/----->: ------->call():8
03-01 10:01:41.030 3591-3736/com.rxandroid.test1 D/----->: ------->call():9

ok,RxJava的过滤操作符就先介绍到这里,更多精彩内容,欢迎关注我的微信公众号——Android机动车

原文发布于微信公众号 - Android机动车(JsAndroidClub)

原文发表时间:2018-08-21

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏算法修养

浙江工业大学校赛 竹之书(大数,同余定理)

竹之书 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java...

32280
来自专栏小樱的经验随笔

BZOJ 3097: Hash Killer I【构造题,思维题】

3097: Hash Killer I Time Limit: 5 Sec  Memory Limit: 128 MBSec  Special Judge Su...

22760
来自专栏進无尽的文章

编码篇-开发中关于数字的那些事儿

在日常的开发中我们随时都会跟数字打着交道,对数字的处理也是很平常的事,本文仅对常用的数字操作一个小结,当一个笔记方便日后查看,也希望读者能从中收获些感觉有用的知...

15310
来自专栏我是攻城师

Fastjson解析嵌套Map例子

47950
来自专栏数据结构与算法

P2580 于是他错误的点名开始了

题目背景 XS中学化学竞赛组教练是一个酷爱炉石的人。 他会一边搓炉石一边点名以至于有一天他连续点到了某个同学两次,然后正好被路过的校长发现了然后就是一顿欧拉欧拉...

32070
来自专栏码匠的流水账

聊聊storm TridentTopology的构建

storm-core-1.2.2-sources.jar!/org/apache/storm/trident/TridentTopology.java

12620
来自专栏HansBug's Lab

3098: Hash Killer II

3098: Hash Killer II Time Limit: 5 Sec  Memory Limit: 128 MBSec  Special Judge S...

30360
来自专栏ml

位运算的方法,大结

Title:       位操作基础篇之位操作全面总结 Author:     MoreWindows E-mail:      morewindows@126...

66180
来自专栏程序你好

如何使用Java Stream Collectors(归约器)?

Java 8引入了Stream API,它允许我们以声明的方式处理数据。此外,Stream还可以在不需要编写多线程代码的情况下使用多核架构。

10610
来自专栏小樱的经验随笔

POJ 2492 A Bug's Life

A Bug's Life Time Limit: 10000MS Memory Limit: 65536K Total Submissions:...

296100

扫码关注云+社区

领取腾讯云代金券