RxJava操作符之过滤操作符(五)

前言

  上一篇文章我们学习了转换类操作符,本篇我们将一起来学习RxJava过滤类操作符。过滤操作符主要是用来对事件数据进行过滤与筛选,只返回满足条件的数据,一起来看下都有哪些。
  

过滤操作符

Filter

  filter操作符,按照一定的约束条件过滤序列中我们不想要的数据,只返回满足条件的数据给观察者。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//结合flatmap,过滤出各小区中房源大小大于120平的房子
Observable.from(communities)
.flatMap(new Func1<Community, Observable<House>>() {
@Override
public Observable<House> call(Community community) {
return Observable.from(community.getHouses());
}
})
.filter(new Func1<House, Boolean>() {
@Override
public Boolean call(House house) {
return house.getSize() > 120f;
}
})
.subscribe(new Action1<House>() {
@Override
public void call(House house) {
Log.e("rx_test", "filter:大于120平的房子:" + house.getCommunityName() + "小区,大小:" + house.getSize());
}
});

  由代码可见,我们需要new一个Func1对象给filter(),Func1<House, Boolean>()中第一个是由观测序列传入数据的类型,第二个是返回是否过滤的Boolean对象。满足filter()的条件则返回true,否则返回false。并将返回为true的数据发射给观察者。
  输出结果:

1
2
3
4
5
6
7
filter:大于120平的房子:东方花园小区,大小:144.8
filter:大于120平的房子:东方花园小区,大小:144.8
filter:大于120平的房子:马德里春天小区,大小:123.4
filter:大于120平的房子:马德里春天小区,大小:123.4
filter:大于120平的房子:帝豪家园小区,大小:188.7
filter:大于120平的房子:帝豪家园小区,大小:188.7
filter:大于120平的房子:帝豪家园小区,大小:188.7

  原理图:


  

  实际项目开发中,filter操作符可用来过滤数据集合中的null值,方便实用。

Take

  take(int count)操作符,可用来截取观测序列中前count个元素并发射。

1
2
3
4
5
6
7
8
9
//take:获取前两个小区名
Observable.from(communities)
.take(2)
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "take:前两个小区:" + community.getCommunityName());
}
});

  输出结果:

1
2
take:前两个小区:东方花园
take:前两个小区:马德里春天

  原理图:


  

TakeLast

  takeLast(int count)操作符,顾名思义,截取观测序列中后count个元素并发射。

1
2
3
4
5
6
7
8
9
//takeLast:获取后两个小区名
Observable.from(communities)
.takeLast(2)
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "takeLast:后两个小区:" + community.getCommunityName());
}
});

  输出结果:

1
2
takeLast:后两个小区:马德里春天
takeLast:后两个小区:帝豪家园

  原理图:


  

TakeUntil

  takeUntil操作符有两种类型的入参。
  1.takeUntil(Observable)
  订阅并开始发射原始Observable,同时监视我们提供的第二个Observable。如果第二个Observable发射了一项数据或者发射了一个终止通知,takeUntil()返回的Observable会停止发射原始Observable并终止。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//observableA每300ms发射一个Long型自增数据
//observableB每800ms发射一个Long型自增数据
Observable<Long> observableA = Observable.interval(300, TimeUnit.MILLISECONDS);
Observable<Long> observableB = Observable.interval(800, TimeUnit.MILLISECONDS);
observableA.takeUntil(observableB)
.subscribe(new Subscriber<Long>() {
@Override
public void onCompleted() {
Log.e("rx_test", "takeUntil(Observable):" + "onCompleted");
}
@Override
public void onError(Throwable e) {
Log.e("rx_test", "takeUntil(Observable):onError:" + e.getMessage());
}
@Override
public void onNext(Long aLong) {
Log.e("rx_test", "takeUntil(Observable):onNext:" + aLong);
}
});

  输出结果:

1
2
3
takeUntil(Observable):onNext:0
takeUntil(Observable):onNext:1
takeUntil(Observable):onCompleted

  由输出结果可看出,订阅之后,observableA依次发射0,1之后就发射onCompleted标记停止了。这是由于observableA每300ms发射一次,当发射完1后,时间已过去600ms,到800ms时observableB开始发射数据,takeUntil起作用则中断了observableA的发射。
  原理图:


  

  2.takeUntil(Func1)
  通过传入的Func1中的call()方法判断是否中止发射数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//takeUntil:与flatmap结合过滤直到房价大于500时中断当前小Observable发射House
Observable.from(communities)
.flatMap(new Func1<Community, Observable<House>>() {
@Override
public Observable<House> call(Community community) {
return Observable.from(community.getHouses());
}
})
.takeUntil(new Func1<House, Boolean>() {
@Override
public Boolean call(House house) {
return house.getPrice() > 500;
}
})
.subscribe(new Action1<House>() {
@Override
public void call(House house) {
Log.e("rx_test", "takeUntil:大于500时中断发射:" + house.getCommunityName() + "小区,房价:" + house.getPrice());
}
});

  输出结果:

1
2
takeUntil(Func1):大于500时中断发射:东方花园小区,房价:200
takeUntil(Func1):大于500时中断发射:东方花园小区,房价:520

  原理图:


  

TakeWhile

  takeWhile操作符,类似于takeUntil(Func1),不过takeWhile()是当Observable发射的数据不满足条件时中止Observable的发射。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//takeWhile:当发射的数据等于3时中止发射
Observable.just(1, 2, 3, 4, 5)
.takeWhile(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer != 3;
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rx_test", "takeWhile:" + integer);
}
});

  输出结果:

1
2
takeWhile:1
takeWhile:2

  原理图:


  

Skip

  skip(int count)操作符,忽略发射观测序列的前count项数据。

1
2
3
4
5
6
7
8
9
//忽略前两个小区数据
Observable.from(communities)
.skip(2)
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "skip:忽略前两个小区:" + community.getCommunityName());
}
});

  输出结果:

1
skip:忽略前两个小区:帝豪家园

  原理图:


  

SkipLast

  skipLast(int count)操作符,忽略发射观测序列的后count项数据。

1
2
3
4
5
6
7
8
9
//忽略后两个小区数据
Observable.from(communities)
.skipLast(2)
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "skip:忽略后两个小区:" + community.getCommunityName());
}
});

  输出结果:

1
忽略后两个小区:东方花园

  原理图:


  

SkipUntil

  skipUntil操作符,与takeUntil()相反。订阅并开始发射原始Observable,同时监视我们提供的第二个Observable。如果第二个Observable发射了一项数据或者发射了一个终止通知,skipUntil()返回的Observable才会开始发射数据,忽略之前的数据项。
  原理图:


  

SkipWhile

  skipWhile操作符,与takeWhile相反,当Observable发射的数据不满足条件时才开始发射数据,忽略之前的数据项。
  原理图:


  

Debounce

  debounce操作符有两种类型的入参。
  1.debounce(long, TimeUnit)
  过滤由Observable发射的速率过快的数据,起到限流的作用。第一个参数为限流时间,第二个参数为时间单位。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
try {
for (int i = 1; i < 10; i++) {
subscriber.onNext(i);
Thread.sleep(i * 100); //分别延时100,200,300,400,500......900ms发射数据
}
subscriber.onCompleted();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).subscribeOn(Schedulers.newThread())
.debounce(400, TimeUnit.MILLISECONDS)
.subscribe(new Observer<Integer>() {
@Override
public void onCompleted() {
Log.e("rx_test", "debounce:" + "onCompleted");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
Log.e("rx_test", "debounce:" + integer);
}
});

  输出结果:

1
2
3
4
5
6
debounce:5
debounce:6
debounce:7
debounce:8
debounce:9
debounce:onCompleted

  由输出结果可以看出由于设定限流时间为500ms,所以1-4并没有被发射而是被过滤了。
  注意:如果源Observable产生的最后一个结果在限流时间内内调用了onCompleted,那么通过debounce操作符也会把这个结果提交给订阅者。
  原理图:


  

  2.debounce(Func1)
  根据Func1的call方法中的函数来过滤。Func1中的中的call方法返回了一个临时的Observable,如果原始的Observable在发射一个新的数据时,上一个数据根据Func1的call方法生成的临时Observable还没结束,那么上一个数据就会被过滤掉。
  原理图:


  

Distinct

  1.distinct()
  只允许还没有发射过的数据通过,达到去除序列中重复项的作用。

1
2
3
4
5
6
7
8
9
//去除重复数字
Observable.just(1, 2, 2, 3, 4, 5, 6, 6, 6, 7)
.distinct()
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rx_test", "distinct:去重:" + integer);
}
});

  输出结果:

1
2
3
4
5
6
7
distinct:去重:1
distinct:去重:2
distinct:去重:3
distinct:去重:4
distinct:去重:5
distinct:去重:6
distinct:去重:7

  由输出结果可见有重复的2和6都被过滤了。
  原理图:


  

  2.distinct(Func1)
  根据Func1中的call方法进行去重,call方法会根据Observable发射的值生成一个Key,然后比较这个key来判断两个数据是否相同,如果判定为重复则会和distinct()一样过滤掉重复的数据项。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//根据某属性去重,去除各小区大小相同的房源
Observable.from(communities)
.flatMap(new Func1<Community, Observable<House>>() {
@Override
public Observable<House> call(Community community) {
return Observable.from(community.getHouses());
}
})
.distinct(new Func1<House, Float>() {
@Override
public Float call(House house) {
return house.getSize();
}
})
.subscribe(new Action1<House>() {
@Override
public void call(House house) {
Log.e("rx_test", "distinct(Func1):去重:" + house.getCommunityName() + "小区,大小:" + house.getSize());
}
});

  输出结果:

1
2
3
4
5
6
distinct(Func1):去重:东方花园小区,大小:105.6
distinct(Func1):去重:东方花园小区,大小:144.8
distinct(Func1):去重:马德里春天小区,大小:88.6
distinct(Func1):去重:马德里春天小区,大小:123.4
distinct(Func1):去重:帝豪家园小区,大小:188.7
distinct(Func1):去重:帝豪家园小区,大小:56.4

DistinctUntilChanged

  1.distinctUntilChanged()
  通过当前数据项与前一项是否相同来进行去重。

1
2
3
4
5
6
7
8
9
//向前去重复数据
Observable.just(1, 2, 2, 3, 4, 2, 3, 5, 5)
.distinctUntilChanged()
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.e("rx_test", "distinctUntilChanged:向前去重:" + integer);
}
});

  输出结果:

1
2
3
4
5
6
7
distinctUntilChanged:向前去重:1
distinctUntilChanged:向前去重:2
distinctUntilChanged:向前去重:3
distinctUntilChanged:向前去重:4
distinctUntilChanged:向前去重:2
distinctUntilChanged:向前去重:3
distinctUntilChanged:向前去重:5

  原理图:


  

  2.distinctUntilChanged(Func1)
  与distinct(Func1)类似,根据Func1中call方法产生一个key来判断相邻两个数据项是否相同。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//根据某属性向前去重,去除各小区名相同的房源
Observable.from(communities)
.flatMap(new Func1<Community, Observable<House>>() {
@Override
public Observable<House> call(Community community) {
return Observable.from(community.getHouses())
.distinctUntilChanged(new Func1<House, String>() {
@Override
public String call(House house) {
return house.getCommunityName();
}
});
}
})
.subscribe(new Action1<House>() {
@Override
public void call(House house) {
Log.e("rx_test", "distinctUntilChanged(Func1):向前去重:" + house.getCommunityName() + "小区,大小:" + house.getSize());
}
});

  输出结果:

1
2
3
distinctUntilChanged(Func1):向前去重:东方花园小区,大小:105.6
distinctUntilChanged(Func1):向前去重:马德里春天小区,大小:88.6
distinctUntilChanged(Func1):向前去重:帝豪家园小区,大小:188.7

ElementAt

  elementAt(int index)操作符,获取观测序列中第index项索引,并作为唯一数据发射给观察者,index索引从0开始。

1
2
3
4
5
6
7
8
Observable.from(communities)
.elementAt(1)
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "elementAt:第二个小区:" + community.getCommunityName());
}
});

  输出结果:

1
elementAt:第二个小区:马德里春天

  原理图:


  

First

  1.first()
  只发射观测序列中的第一个数据项。

1
2
3
4
5
6
7
8
Observable.from(communities)
.first()
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "first:" + community.getCommunityName());
}
});

  输出结果:

1
first:东方花园

  原理图:


  

  2.first(Func1)
  根据Func1中call方法的条件,发射符合条件的第一个数据项。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//过滤出第一个小区名为马德里春天的小区
Observable.from(communities)
.first(new Func1<Community, Boolean>() {
@Override
public Boolean call(Community community) {
return "马德里春天".equals(community.getCommunityName());
}
})
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "first(Func1):" + community.getCommunityName());
}
});

  输出结果:

1
first(Func1):马德里春天

Last

  1.last()
  只发射观测序列中的最后一个数据项。

1
2
3
4
5
6
7
8
9
//发送最后一个数据项
Observable.from(communities)
.last()
.subscribe(new Action1<Community>() {
@Override
public void call(Community community) {
Log.e("rx_test", "last:" + community.getCommunityName());
}
});

  输出结果:

1
last:帝豪家园

  原理图:


  

  2.last(Func1)
  根据Func1中call方法的条件,发射符合条件的最后一个数据项。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//发送符合条件的最后一个数据项:过滤最后一个小区名为马德里春天的房源
Observable.from(communities)
.flatMap(new Func1<Community, Observable<House>>() {
@Override
public Observable<House> call(Community community) {
return Observable.from(community.getHouses());
}
})
.last(new Func1<House, Boolean>() {
@Override
public Boolean call(House house) {
return "马德里春天".equals(house.getCommunityName());
}
})
.subscribe(new Action1<House>() {
@Override
public void call(House house) {
Log.e("rx_test", "last:" + house.getCommunityName() + "小区,大小:" + house.getSize());
}
});

  输出结果:

1
last:马德里春天小区,大小:88.6

总结

  到此,本篇关于RxJava的常用过滤类操作符就讲解完毕了,下一篇我们将一起研究RxJava的四类操作符中的组合操作符都有哪些以及如何使用。
  技术渣一枚,有写的不对的地方欢迎大神们留言指正,有什么疑惑或者建议也可以在我Github上RxJavaDemo项目Issues中提出,我会及时回复。
  附上RxJavaDemo的地址:
  RxJavaDemo   

坚持原创技术分享,您的支持是我前进的动力,谢谢!