Rxjava 过滤操作符

参考：https://www.jianshu.com/p/c3a930a03855

作用 ：对多个事件进行过滤

1. filter

2. take

3. distinct

4. elementAt （指定）

1 filter

例如：一堆商品中选出已经过期的商品 其他的不处理

    @Test
    public void testFilter() throws Exception {
        Observable.just(1, 2, 3, 4, 5, 6).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 2;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                System.out.println(integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

输出结果

3
4
5
6

2 take

指定观察者最多能接收到的事件数量

 @Test
    public void testTake2() {
        Observable.just(1, 2, 3, 4, 5, 6).take(2)
                .subscribe(new Observer<Integer>() {

                    @Override
                    public void onSubscribe(Disposable d) {
                        System.out.println("开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Integer value) {
                        System.out.println("过滤后得到的事件是：" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        System.out.println("对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        System.out.println("对Complete事件作出响应");
                    }
                });

// 实际上，可理解为：被观察者还是发送了5个事件，只是因为操作符的存在拦截了3个事件，最终观察者接收到的是2个事件
    }

输出结果：

开始采用subscribe连接
过滤后得到的事件是：1
过滤后得到的事件是：2
对Complete事件作出响应

3 distinct

    @Test
    public void testDistinct() {
        // 使用1：过滤事件序列中重复的事件
        Observable.just(1, 2, 3, 1, 2)
                .distinct()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("不重复的整型事件元素是： " + integer);
                    }
                });

        // 使用2：过滤事件序列中 连续重复的事件
        // 下面序列中，连续重复的事件 = 3、4
        Observable.just(1, 2, 3, 1, 2, 3, 3, 4, 4)
                .distinctUntilChanged()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("不连续重复的整型事件元素是： " + integer);
                    }
                });
    }

输出结果:

不重复的整型事件元素是： 1
不重复的整型事件元素是： 2
不重复的整型事件元素是： 3
不连续重复的整型事件元素是： 1
不连续重复的整型事件元素是： 2
不连续重复的整型事件元素是： 3
不连续重复的整型事件元素是： 1
不连续重复的整型事件元素是： 2
不连续重复的整型事件元素是： 3
不连续重复的整型事件元素是： 4

4 elementAt

指定接收某个元素（通过 索引值 确定）

注：允许越界，即获取的位置索引 ＞ 发送事件序列长度

 @Test
    public void elementAt() {
        // 使用1：获取位置索引 = 2的 元素
        // 位置索引从0开始
        Observable.just(1, 2, 3, 4, 5)
                .elementAt(2)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("获取到的事件元素是： " + integer);
                    }
                });

// 使用2：获取的位置索引 ＞ 发送事件序列长度时，设置默认参数
        Observable.just(1, 2, 3, 4, 5)
                .elementAt(6, 10)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        System.out.println("获取到的事件元素是： " + integer);
                    }
                });

    }

打印结果：

获取到的事件元素是： 3
获取到的事件元素是： 10