Android从零开始学习Rxjava2（六）—— 过滤运算符

rxjava2过滤运算符

筛选源Observable发出的项的运算符。

Debounce

如果特定的时间跨度已经过去而没有发出另一个项目，则从Observable中发出这一个项目。

debounce主要是防抖。如果在短时间内连续更改并且我们只要最终结果，中间更改的数据对我们来说没有用，需要忽略掉，则debounce是很有效的一个运算符。
debounce的防抖动时间片段是在元素发射之后重新计算的，比如上图黄色圆发射之后，在防抖动时间之内发射第二个绿色的圆，防抖动时间会从绿色的圆开始重新计时。

举个例子：去抖500ms内连续发射的元素，只发射最后一个。

private void doSomeWork() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // send events with simulated time wait
                emitter.onNext(1); // skip
                Thread.sleep(400);
                emitter.onNext(2); // deliver
                Thread.sleep(505);
                emitter.onNext(3); // skip
                Thread.sleep(100);
                emitter.onNext(4); // deliver
                Thread.sleep(605);
                emitter.onNext(5); // deliver
                Thread.sleep(510);
                emitter.onComplete();
            }
        }).debounce(500, TimeUnit.MILLISECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, " accept : integer : " + integer);
                    }
                });
    }

打印结果

accept : integer : 2
accept : integer : 4
accept : integer : 5

Distinct

抑制Observable发出的重复项。

distinct 只允许不同的数据发射出来，去除重复已经发射过的数据。
举个例子：

private void doSomeWork() {
        Observable.just(1, 2, 1, 1, 2, 3, 4, 6, 4)
                .distinct()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, " accept : integer : " + integer);
                    }
                });
    }

打印结果，distinct会将已经发送过的数据忽略掉，所以第三、四、五个元素被去重掉了。

accept : integer : 1
accept : integer : 2
accept : integer : 3
accept : integer : 4
accept : integer : 6

当然distinct不仅仅简单的去除重复数据，也可以设置去重条件，根据条件去重。

举个例子，去除姓名相同的数据：

public class Person{
        String name = "";
        String sex = "";

        public Person(String name, String sex) {
            this.name = name;
            this.sex = sex;
        }
    }

    private void doSomeWork() {
        Observable.just(new Person("张三", "男"), new Person("李四", "男"),
                new Person("张三", "女"), new Person("李四", "男"), new Person("王五", "女"))
                .distinct(new Function<Person, String>() {
                    @Override
                    public String apply(Person person) throws Exception {
                        return person.name;//去重条件，去除后面发射的姓名相同的元素
                    }
                }).subscribe(new Consumer<Person>() {
            @Override
            public void accept(Person person) throws Exception {
                Log.d(TAG, " accept : name : " + person.name + ",sex :" + person.sex);
            }
        });
    }

打印结果

accept : name : 张三,sex :男
accept : name : 李四,sex :男
accept : name : 王五,sex :女

distinctUntilChanged

RxGroovy还实现了distinctUntilChanged运算符。 它仅将源Observable中的发射项与其前一个前辈进行比较，以确定它们是否是不同的。

distinctUntilChanged与distinct类似也是去除重复的元素，也可以自己设置去重的条件，但distinctUntilChanged与distinct不同之处在于distinctUntilChanged它只是将要发射的元素与前一个元素比较，来判断是否需要去除；distinct会将要发射的元素与之前所有元素比较，来判断是否需要去除。
将上方的例子进行更改：

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

打印结果

accept : integer : 1
accept : integer : 2
accept : integer : 1
accept : integer : 2
accept : integer : 3
accept : integer : 4
accept : integer : 6
accept : integer : 4

Filter

过滤运算符，以特定条件过滤发射的元素。

举个例子，筛选出0到9中到偶数：

private void doSomeWork() {
        Observable.range(0, 10)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer % 2 == 0;//筛选条件
                    }
                })
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, " accept : integer : " + integer);
                    }
                });
    }

打印结果

accept : integer : 0
accept : integer : 2
accept : integer : 4
accept : integer : 6
accept : integer : 8

sample / throttleLast

在定期时间间隔内发出Observable发出的最新项目。Sample运算符定期查看Observable并发出自上次采样以来最近发出的任何项目。

举个例子：

private void doSomeWork() {
        Observable.interval(100, TimeUnit.MILLISECONDS).take(10)
                .sample(300,TimeUnit.MILLISECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG, " accept : aLong : " + aLong);
                    }
                });
    }

打印结果

accept : aLong : 2
accept : aLong : 4
accept : aLong : 7

sample和throttleLast的作用效果一样，都是只发射出定期间隔期内所缓冲所有元素里最后一个元素。与之相对应的是throttleFirst，会发射出定期间隔期内所缓冲所有元素里第一个元素。

例子就不再重复写了，想测试可以将上面改下，比较简单。打印结果：

accept : aLong : 0
accept : aLong : 4
accept : aLong : 8

还有其他一些过滤运算符比如Last、Skip、Take 等，可以根据名字就知道其准确的用法，我就不一一写出来了。

---

参考资料，参考但不局限以下链接
http://reactivex.io/documentation/operators.html#transforming