RxJava操作符之过滤操作符(五)

前言

  上一篇文章我们学习了转换类操作符,本篇我们将一起来学习RxJava过滤类操作符。过滤操作符主要是用来对事件数据进行过滤与筛选,只返回满足条件的数据,一起来看下都有哪些。
  

过滤操作符

Filter

  filter操作符,按照一定的约束条件过滤序列中我们不想要的数据,只返回满足条件的数据给观察者。

//结合flatmap,过滤出各小区中房源大小大于120平的房子
Observable.from(communities)
        .flatMap(new Func1<Community, Observable<House>>() {
            @Override
            public Observable<House> call(Community community) {
                return Observable.from(community.getHouses());
            }
        })
        .filter(new Func1<House, Boolean>() {
            @Override
            public Boolean call(House house) {
                return house.getSize() > 120f;
            }
        })
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                Log.e("rx_test", "filter:大于120平的房子:" + house.getCommunityName() + "小区,大小:" + house.getSize());
            }
        });

  由代码可见,我们需要new一个Func1对象给filter(),Func1<House, Boolean>()中第一个是由观测序列传入数据的类型,第二个是返回是否过滤的Boolean对象。满足filter()的条件则返回true,否则返回false。并将返回为true的数据发射给观察者。
  输出结果:

filter:大于120平的房子:东方花园小区,大小:144.8
filter:大于120平的房子:东方花园小区,大小:144.8
filter:大于120平的房子:马德里春天小区,大小:123.4
filter:大于120平的房子:马德里春天小区,大小:123.4
filter:大于120平的房子:帝豪家园小区,大小:188.7
filter:大于120平的房子:帝豪家园小区,大小:188.7
filter:大于120平的房子:帝豪家园小区,大小:188.7

  原理图:


  实际项目开发中,filter操作符可用来过滤数据集合中的null值,方便实用。

Take

  take(int count)操作符,可用来截取观测序列中前count个元素并发射。

//take:获取前两个小区名
Observable.from(communities)
        .take(2)
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "take:前两个小区:" + community.getCommunityName());
            }
        });

  输出结果:

take:前两个小区:东方花园
take:前两个小区:马德里春天

  原理图:


TakeLast

  takeLast(int count)操作符,顾名思义,截取观测序列中后count个元素并发射。

//takeLast:获取后两个小区名
Observable.from(communities)
        .takeLast(2)
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "takeLast:后两个小区:" + community.getCommunityName());
            }
        });

  输出结果:

takeLast:后两个小区:马德里春天
takeLast:后两个小区:帝豪家园

  原理图:


TakeUntil

  takeUntil操作符有两种类型的入参。
  1.takeUntil(Observable)
  订阅并开始发射原始Observable,同时监视我们提供的第二个Observable。如果第二个Observable发射了一项数据或者发射了一个终止通知,takeUntil()返回的Observable会停止发射原始Observable并终止。

//observableA每300ms发射一个Long型自增数据
//observableB每800ms发射一个Long型自增数据
Observable<Long> observableA = Observable.interval(300, TimeUnit.MILLISECONDS);
Observable<Long> observableB = Observable.interval(800, TimeUnit.MILLISECONDS);
observableA.takeUntil(observableB)
        .subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {
                Log.e("rx_test", "takeUntil(Observable):" + "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("rx_test", "takeUntil(Observable):onError:" + e.getMessage());
            }

            @Override
            public void onNext(Long aLong) {
                Log.e("rx_test", "takeUntil(Observable):onNext:" + aLong);
            }
        });

  输出结果:

takeUntil(Observable):onNext:0
takeUntil(Observable):onNext:1
takeUntil(Observable):onCompleted

  由输出结果可看出,订阅之后,observableA依次发射0,1之后就发射onCompleted标记停止了。这是由于observableA每300ms发射一次,当发射完1后,时间已过去600ms,到800ms时observableB开始发射数据,takeUntil起作用则中断了observableA的发射。
  原理图:


  2.takeUntil(Func1)
  通过传入的Func1中的call()方法判断是否中止发射数据。

//takeUntil:与flatmap结合过滤直到房价大于500时中断当前小Observable发射House
Observable.from(communities)
        .flatMap(new Func1<Community, Observable<House>>() {
            @Override
            public Observable<House> call(Community community) {
                return Observable.from(community.getHouses());
            }
        })
        .takeUntil(new Func1<House, Boolean>() {
            @Override
            public Boolean call(House house) {
                return house.getPrice() > 500;
            }
        })
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                Log.e("rx_test", "takeUntil:大于500时中断发射:" + house.getCommunityName() + "小区,房价:" + house.getPrice());
            }
        });

  输出结果:

takeUntil(Func1):大于500时中断发射:东方花园小区,房价:200
takeUntil(Func1):大于500时中断发射:东方花园小区,房价:520

  原理图:


TakeWhile

  takeWhile操作符,类似于takeUntil(Func1),不过takeWhile()是当Observable发射的数据不满足条件时中止Observable的发射。

//takeWhile:当发射的数据等于3时中止发射
Observable.just(1, 2, 3, 4, 5)
        .takeWhile(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer != 3;
            }
        })
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("rx_test", "takeWhile:" + integer);
            }
        });

  输出结果:

takeWhile:1
takeWhile:2

  原理图:


Skip

  skip(int count)操作符,忽略发射观测序列的前count项数据。

//忽略前两个小区数据
Observable.from(communities)
        .skip(2)
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "skip:忽略前两个小区:" + community.getCommunityName());
            }
        });

  输出结果:

skip:忽略前两个小区:帝豪家园

  原理图:


SkipLast

  skipLast(int count)操作符,忽略发射观测序列的后count项数据。

//忽略后两个小区数据
Observable.from(communities)
        .skipLast(2)
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "skip:忽略后两个小区:" + community.getCommunityName());
            }
        });

  输出结果:

忽略后两个小区:东方花园

  原理图:


SkipUntil

  skipUntil操作符,与takeUntil()相反。订阅并开始发射原始Observable,同时监视我们提供的第二个Observable。如果第二个Observable发射了一项数据或者发射了一个终止通知,skipUntil()返回的Observable才会开始发射数据,忽略之前的数据项。
  原理图:


SkipWhile

  skipWhile操作符,与takeWhile相反,当Observable发射的数据不满足条件时才开始发射数据,忽略之前的数据项。
  原理图:


Debounce

  debounce操作符有两种类型的入参。
  1.debounce(long, TimeUnit)
  过滤由Observable发射的速率过快的数据,起到限流的作用。第一个参数为限流时间,第二个参数为时间单位。

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        try {
            for (int i = 1; i < 10; i++) {
                subscriber.onNext(i);
                Thread.sleep(i * 100); //分别延时100,200,300,400,500......900ms发射数据
            }
            subscriber.onCompleted();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).subscribeOn(Schedulers.newThread())
        .debounce(400, TimeUnit.MILLISECONDS)
        .subscribe(new Observer<Integer>() {
            @Override
            public void onCompleted() {
                Log.e("rx_test", "debounce:" + "onCompleted");
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onNext(Integer integer) {
                Log.e("rx_test", "debounce:" + integer);
            }
        });

  输出结果:

debounce:5
debounce:6
debounce:7
debounce:8
debounce:9
debounce:onCompleted

  由输出结果可以看出由于设定限流时间为500ms,所以1-4并没有被发射而是被过滤了。
  注意:如果源Observable产生的最后一个结果在限流时间内内调用了onCompleted,那么通过debounce操作符也会把这个结果提交给订阅者。
  原理图:


  2.debounce(Func1)
  根据Func1的call方法中的函数来过滤。Func1中的中的call方法返回了一个临时的Observable,如果原始的Observable在发射一个新的数据时,上一个数据根据Func1的call方法生成的临时Observable还没结束,那么上一个数据就会被过滤掉。
  原理图:


Distinct

  1.distinct()
  只允许还没有发射过的数据通过,达到去除序列中重复项的作用。

//去除重复数字
Observable.just(1, 2, 2, 3, 4, 5, 6, 6, 6, 7)
        .distinct()
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("rx_test", "distinct:去重:" + integer);
            }
        });

  输出结果:

distinct:去重:1
distinct:去重:2
distinct:去重:3
distinct:去重:4
distinct:去重:5
distinct:去重:6
distinct:去重:7

  由输出结果可见有重复的2和6都被过滤了。
  原理图:


  2.distinct(Func1)
  根据Func1中的call方法进行去重,call方法会根据Observable发射的值生成一个Key,然后比较这个key来判断两个数据是否相同,如果判定为重复则会和distinct()一样过滤掉重复的数据项。

//根据某属性去重,去除各小区大小相同的房源
Observable.from(communities)
        .flatMap(new Func1<Community, Observable<House>>() {
            @Override
            public Observable<House> call(Community community) {
                return Observable.from(community.getHouses());
            }
        })
        .distinct(new Func1<House, Float>() {
            @Override
            public Float call(House house) {
                return house.getSize();
            }
        })
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                Log.e("rx_test", "distinct(Func1):去重:" + house.getCommunityName() + "小区,大小:" + house.getSize());
            }
        });

  输出结果:

distinct(Func1):去重:东方花园小区,大小:105.6
distinct(Func1):去重:东方花园小区,大小:144.8
distinct(Func1):去重:马德里春天小区,大小:88.6
distinct(Func1):去重:马德里春天小区,大小:123.4
distinct(Func1):去重:帝豪家园小区,大小:188.7
distinct(Func1):去重:帝豪家园小区,大小:56.4

DistinctUntilChanged

  1.distinctUntilChanged()
  通过当前数据项与前一项是否相同来进行去重。

//向前去重复数据
Observable.just(1, 2, 2, 3, 4, 2, 3, 5, 5)
        .distinctUntilChanged()
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("rx_test", "distinctUntilChanged:向前去重:" + integer);
            }
        });

  输出结果:

distinctUntilChanged:向前去重:1
distinctUntilChanged:向前去重:2
distinctUntilChanged:向前去重:3
distinctUntilChanged:向前去重:4
distinctUntilChanged:向前去重:2
distinctUntilChanged:向前去重:3
distinctUntilChanged:向前去重:5

  原理图:


  2.distinctUntilChanged(Func1)
  与distinct(Func1)类似,根据Func1中call方法产生一个key来判断相邻两个数据项是否相同。

//根据某属性向前去重,去除各小区名相同的房源
Observable.from(communities)
        .flatMap(new Func1<Community, Observable<House>>() {
            @Override
            public Observable<House> call(Community community) {
                return Observable.from(community.getHouses())
                .distinctUntilChanged(new Func1<House, String>() {
                    @Override
                    public String call(House house) {
                        return house.getCommunityName();
                    }
                });
            }
        })
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                Log.e("rx_test", "distinctUntilChanged(Func1):向前去重:" + house.getCommunityName() + "小区,大小:" + house.getSize());
            }
        });

  输出结果:

distinctUntilChanged(Func1):向前去重:东方花园小区,大小:105.6
distinctUntilChanged(Func1):向前去重:马德里春天小区,大小:88.6
distinctUntilChanged(Func1):向前去重:帝豪家园小区,大小:188.7

ElementAt

  elementAt(int index)操作符,获取观测序列中第index项索引,并作为唯一数据发射给观察者,index索引从0开始。

Observable.from(communities)
        .elementAt(1)
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "elementAt:第二个小区:" + community.getCommunityName());
            }
        });

  输出结果:

elementAt:第二个小区:马德里春天

  原理图:


First

  1.first()
  只发射观测序列中的第一个数据项。

Observable.from(communities)
        .first()
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "first:" + community.getCommunityName());
            }
        });

  输出结果:

first:东方花园

  原理图:


  2.first(Func1)
  根据Func1中call方法的条件,发射符合条件的第一个数据项。

//过滤出第一个小区名为马德里春天的小区
Observable.from(communities)
        .first(new Func1<Community, Boolean>() {
            @Override
            public Boolean call(Community community) {
                return "马德里春天".equals(community.getCommunityName());
            }
        })
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "first(Func1):" + community.getCommunityName());
            }
        });

  输出结果:

first(Func1):马德里春天

Last

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

//发送最后一个数据项
Observable.from(communities)
        .last()
        .subscribe(new Action1<Community>() {
            @Override
            public void call(Community community) {
                Log.e("rx_test", "last:" + community.getCommunityName());
            }
        });

  输出结果:

last:帝豪家园

  原理图:


  2.last(Func1)
  根据Func1中call方法的条件,发射符合条件的最后一个数据项。

//发送符合条件的最后一个数据项:过滤最后一个小区名为马德里春天的房源
Observable.from(communities)
        .flatMap(new Func1<Community, Observable<House>>() {
            @Override
            public Observable<House> call(Community community) {
                return Observable.from(community.getHouses());
            }
        })
        .last(new Func1<House, Boolean>() {
            @Override
            public Boolean call(House house) {
                return "马德里春天".equals(house.getCommunityName());
            }
        })
        .subscribe(new Action1<House>() {
            @Override
            public void call(House house) {
                Log.e("rx_test", "last:" + house.getCommunityName() + "小区,大小:" + house.getSize());
            }
        });

  输出结果:

last:马德里春天小区,大小:88.6

总结

  到此,本篇关于RxJava的常用过滤类操作符就讲解完毕了,下一篇我们将一起研究RxJava的四类操作符中的组合操作符都有哪些以及如何使用。
  技术渣一枚,有写的不对的地方欢迎大神们留言指正,有什么疑惑或者建议也可以在我Github上RxJavaDemo项目Issues中提出,我会及时回复。
  附上RxJavaDemo的地址:
  RxJavaDemo

展开阅读全文
©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值