RxJava进阶三（过滤类操作符）

发表于 | 分类于 ， | 阅读次数
上篇文章我们了解了RXJava的转换类操作符，本篇文章带着大家熟悉一下RxJava的过滤类操作符，本系列文章仅是带大家认识一下这些操作符的用法，并没有对操作符进行多种形态的使用，具体的还需要大家在使用时注意~

RxJava进阶

RxJava进阶一（创建类操作符）
RxJava进阶二（转换类操作符）
RxJava进阶三（过滤类操作符）
RxJava进阶四（组合类操作符）

前言

上篇文章我们了解了RXJava的转换类操作符，本篇文章带着大家熟悉一下RxJava的过滤类操作符，本系列文章仅是带大家认识一下这些操作符的用法，并没有对操作符进行多种形态的使用，具体的还需要大家在使用时注意~

操作符总览

Debounce、Distinct、ElementAt、Filter、First、IgnoreElements、Last、Sample、Skip、SkipLast、Take、TakeLast…

具体使用介绍

####Debounce ##

debounce操作符在源Observable产品一个结果时开始计时，如果在规定的间隔时间内没有别的结果产生或者在此期间调用了onCompleted，则发射数据，否则忽略发射。

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Observable
        .create((Observable.OnSubscribe<Integer>) subscriber -> {
            try {
                //产生结果的间隔时间分别为100、200、300...900毫秒
                for (int i = 1; i < 10; i++) {
                    subscriber.onNext(i);
                    Thread.sleep(i * 100);
                }
                subscriber.onCompleted();
            } catch (Exception e) {
                subscriber.onError(e);
            }
        })
        .debounce(400, TimeUnit.MILLISECONDS)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println(integer);
            }
        });

运行结果：

debounce示例

Distinct

去重，过滤掉重复数据项~

1
2
3
4
5
6
7
8
9
Observable
        .just(1, 1, 2, 2, 3)
        .distinct()
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println(integer);
            }
        });

运行结果：

distinct示例

####ElementAt##

取值，取特定位置的数据项，索引是从0开始的~

代码示例：

1
2
3
4
5
6
7
8
9
Observable
        .just(100, 101, 102, 103, 104)
        .elementAt(4)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

elementAt示例

####Filter##

对发射的数据进行过滤，只发射符合条件的数据~

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Observable
        .just(100, 101, 102, 103, 104)
        .filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer >= 102;
            }
        })
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

filter示例

####First##

首项，只发射首项或满足条件的首项数据~

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Observable
        .just(100, 101, 102, 103, 104)
        .first(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer >= 102;
            }
        })
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

first示例

####Last##

末项，只发射末项或满足条件的末项数据~

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Observable
        .just(100, 101, 102, 103, 104)
        .last(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                return integer <= 102;
            }
        })
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

last示例

####IgnoreElements##

忽略所有数据，只保留终止通知(onError或onCompleted)~

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//  ignoreElements
Observable
        .just(100, 101, 102, 103, 104)
        .ignoreElements()
        .subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("onCompleted");
            }
            @Override
            public void onError(Throwable e) {
                System.out.println("onError");
            }
            @Override
            public void onNext(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

ignoreElements示例

####Sample##

取样，定期扫描源Observable产生的数据，发射最新的数据~

示例代码：

1
2
3
4
5
6
7
8
9
Observable
        .interval(100, TimeUnit.MILLISECONDS)
        .sample(200, TimeUnit.MILLISECONDS)
        .subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                System.out.println(aLong);
            }
        });

运行结果：

截取的部分输出结果，从输出结果可以看出，每次发射的数据都是偶数~

sample示例

####Skip##

跳过前面的n项数据不进行处理~

示例代码：

1
2
3
4
5
6
7
8
9
Observable
        .just(1, 2, 3, 4, 5)
        .skip(2)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

skip示例

####SkipLast##

跳过后面的n项数据不进行处理~

示例代码：

1
2
3
4
5
6
7
8
9
Observable
        .just(1, 2, 3, 4, 5)
        .skipLast(2)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

skipLast示例

####Take##

与skip用法相反，保留前面的n项数据进行发射，而忽略后面的结果~

示例代码：

1
2
3
4
5
6
7
8
9
Observable
        .just(1, 2, 3, 4, 5)
        .take(3)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

take示例

####TakeLast##

与skipLast用法相反，只保留后面的n项数据进行发射，而忽略前面的结果~

示例代码：

1
2
3
4
5
6
7
8
9
Observable
        .just(1, 2, 3, 4, 5)
        .takeLast(3)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("onNext -->" + integer);
            }
        });

运行结果：

takeLast示例

结语

过滤类操作符，就简单介绍到这里，希望能够对同学有所帮助，谢谢~