RxJava过滤操作符笔记

过滤操作

我觉得对于过滤操作看下面这个图就够了。之后就是熟悉使用多敲敲吧。
详细看着里

filter( ) — 过滤数据
take 只发射前面的N项数据

filter

Filter操作符使用你指定的一个谓词函数测试数据项，只有通过测试的数据才会被发射。
filter( ) — 过滤数据

 Observable.just(1,2,3,4,5,6,7,7,8,2)
                .filter(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer%2 ==0;
                    }
                }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.i(TAG, "call: "+integer);
            }
        });

ofType

        //ofType
        //ofType是filter操作符的一个特殊形式。它过滤一个Observable只返回指定类型的数据。
        //ofType默认不在任何特定的调度器上指定。
        Observable.just(1,"Arya Stark",3,"jon snow",5,"Tyrion",7)
                .ofType(String.class)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, "call: "+s);
                    }
                });

take

take 只发射前面的N项数据

 String[] strs = {"Arya Stark","jon snow","Tyrion"};
        Observable.from(strs)
                .take(2)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, "call: "+s);
                    }
                });

takelast

takelast发射Observable发射的最后N项数据

String[] strs = {"Arya Stark","jon snow","Tyrion"};
        Observable.from(strs)
                .takeLast(2)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, "call: "+s);
                    }
                });

last

last只发射最后一项（或者满足某个条件的最后一项）数据

  String[] strs = {"Arya Stark","jon snow","Tyrion"};
        Observable.from(strs).last()
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.i(TAG, "call: "+s);
                    }
                });

skip

skip抑制Observable发射的前N项数据

Observable.just(1,2,3,4,5,6)
                .skip(2)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: "+integer);
                    }
                });

skiplast

skiplast//抑制Observable发射的后N项数据

 Observable.just(1,2,3,4,5,6)
                .skipLast(2)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: "+integer);
                    }
                });

distinct

distinct抑制（过滤掉）重复的数据项

Observable.just(1,2,3,5,2,2,3)
                .distinct()
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: "+integer);
                    }
                });

debounce

debounce仅在过了一段指定的时间还没发射数据时才发射一个数据

Observable.just(1,2,3,4,5,6,7,8,9)
                .debounce(2,TimeUnit.SECONDS)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: "+integer);
                    }
                });

elementAt

elementat只发射第N项数据

RxJava将这个操作符实现为elementAt，给它传递一个基于0的索引值，它会发射原始Observable数据序列对应索引位置的值，如果你传递给elementAt的值为5，那么它会发射第六项的数据。

Observable.just(1,2,3,4)
                .elementAt(2)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.i(TAG, "call: "+integer);
                    }
                }); //输出3

sample

sample定期发射Observable最近发射的数据项

Observable.interval(1,TimeUnit.SECONDS)
                .sample(5,TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.i(TAG, "call: "+aLong);
                    }
                });

ignoreElements

不发射任何数据，只发射Observable的终止通知