Rxjava(三)之过滤操作符与条件操作符

前言

上文我们介绍了创建操作符和变换操作符。这里我们接着介绍过滤操作符和条件操作符。

过滤型操作符

过滤型操作符顾名思义是过滤掉被观察者中发送的数据，然后将过滤后的数据再发送给观察者。常见的过滤型操作符有filter、take、distinct、elementAl。

filter操作符

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                if (integer == 2){
                    return  false;
                }
                return true;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        });

 accept: 1
 accept: 3

同样的过滤型操作符也是在被观察者和观察者之间加入。
由代码和输出日志结果可以看到，当我们在filter操作符中的test方法中返回为false的时候，对应的值便不会再发送给观察者了。

take操作符

Observable.interval(5, TimeUnit.SECONDS).
                take(4).
                subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG, "accpt: " + aLong);
                    }
                });

accpt: 0
accpt: 1
accpt: 2
accpt: 3

take操作符是指定下游接到的事件数量，在上述代码中，我们加入了一个定时器，每隔5S执行，这样，我们接收到的结果就只会执行4次。

distinct操作符

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(2);
                e.onNext(3);
            }
        }).
        distinct().
        subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accpt: " + integer);
            }
        });

accpt: 1
accpt: 2
accpt: 3

由结果不难看出，distinct操作符的意义就是过滤掉重复数据。

elementAl操作符

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("张三");
                e.onNext("李四");
                e.onNext("王五");
                e.onComplete();
            }
        }).
        elementAt(10,"无名").
        subscribe(new Consumer<String>() {
            @Override
            public void accept(String str) throws Exception {
                Log.d(TAG, "accpt: " + str);
            }
        });

accpt: 无名

elementAl操作符发送指定内容，如果指定下标为空，那么则发送默认值。
这里需要注意的是，要发送默认值必须在elementAt操作符后填入默认值，并且一定要发送onComplete事件，否则观察者是收不到消息的。

条件型操作符

条件型操作符就是在被观察者和观察者之间加入一个判断条件，然后下游默认返回布尔值。常见的条件操作符有：all,contains,any。
all操作符

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("张三");
                e.onNext("李四");
                e.onNext("王五");
                e.onComplete();
            }
        }).all(new Predicate<String>() {
            @Override
            public boolean test(String s) throws Exception {
                return s.equals("李四");
            }
        })
        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean b) throws Exception {
                Log.d(TAG, "accpt: " + b);
            }
        });

accpt: false

all操作符如同if一样的功能全部为true，才是true，只要有一个为false，就是false.
剩下两个条件操作符这里就简单介绍一下。
contains 是否包含。
any 全部为 false，才是false， 只要有一个为true，就是true。