RxJava 过滤操作符

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

图片描述

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

filter

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

filter

1
2
3
4
5
6
7
8
9
10
11
12
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

1
2
3
4
5
6
7
8
9
10
11
//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项数据

take

1
2
3
4
5
6
7
8
9
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项数据

takelast

1
2
3
4
5
6
7
8
9
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只发射最后一项(或者满足某个条件的最后一项)数据
last

1
2
3
4
5
6
7
8
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项数据
skip

1
2
3
4
5
6
7
8
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项数据
skiplast

1
2
3
4
5
6
7
8
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抑制(过滤掉)重复的数据项
distinct

1
2
3
4
5
6
7
8
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仅在过了一段指定的时间还没发射数据时才发射一个数据
debounce

1
2
3
4
5
6
7
8
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项数据
elementat
RxJava将这个操作符实现为elementAt,给它传递一个基于0的索引值,它会发射原始Observable数据序列对应索引位置的值,如果你传递给elementAt的值为5,那么它会发射第六项的数据。

1
2
3
4
5
6
7
8
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最近发射的数据项
sample

1
2
3
4
5
6
7
8
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的终止通知