前言

　　上一篇文章我们学习了转换类操作符，本篇我们将一起来学习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