Filter
RxJava让我们使用filter()方法来过滤观测序列中我们不想要的值。
-
先来个没有带过滤的
public static void main(String... args) { Observable.create(new Observable.OnSubscribe
() { @Override public void call(Subscriber subscriber) { subscriber.onNext("张三"); subscriber.onNext("李四"); subscriber.onNext("王五"); } }).subscribe(new Observer () { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(String s) { System.out.println("我是" + s); } }); }
打印结果:
我是张三
我是李四
我是王五
-
现在在创建Observable之后添加filter()方法。
public static void main(String... args) { Observable.create(new Observable.OnSubscribe
() { @Override public void call(Subscriber subscriber) { subscriber.onNext("张三"); subscriber.onNext("李四"); subscriber.onNext("王五"); } }).filter(new Func1 () { @Override public Boolean call(String s) { return s.startsWith("李"); } }).subscribe(new Observer () { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(String s) { System.out.println("我是" + s); } }); } 可以看到添加的filter()方法,判断字符串是否以"李"开头,返回一个布尔值,只要条件符合filter()函数就会返回true。此时,该值就会发送出去。
打印结果:
我是李四
Take
许多时候,可能生产者(也就是被观察者)订阅了好几个消费者(也就是观察者),以后就用生产者和消费者来叙述,观察者和被观察者拗口得要命有木有!言归正传,生产者会产生一条数据流,而你消费者可能仅仅只需要开头或者结尾的几个元素,那么RxJava也为我们提供了take()和takeLast()方法来实现。
-
take(),如果我们只想要一个观测序列中的前两个元素,给take()传入参数:整数2,就能实现。
public static void main(String... args) { Observable.create(new Observable.OnSubscribe
() { @Override public void call(Subscriber subscriber) { subscriber.onNext("张三"); subscriber.onNext("李四"); subscriber.onNext("王五"); } }) .take(2) .subscribe(new Observer () { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(String s) { System.out.println("我是" + s); } }); }
打印结果:
我是张三
我是李四
在这里的take(n),表示的是说生产者发送前n个数据,n = 2 也就发送前两个数据,并不是说数据全部发完,截取前两个数据。
-
takeLast()能够让我们发送后几个数据元素。
public static void main(String... args) { Observable.create(new Observable.OnSubscribe
() { @Override public void call(Subscriber subscriber) { subscriber.onNext("张三"); subscriber.onNext("李四"); subscriber.onNext("王五"); subscriber.onCompleted(); } }) .takeLast(1) .subscribe(new Observer () { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(String s) { System.out.println("我是" + s); } }); }
同样的,不能少了subscriber.onCompleted()
。
打印结果:
我是王五
Distinct
distinct()作用于一个完整的序列,所有重复的数据项只会发射一次。
public static void main(String... args) {
Observable.just(1,2,1,2)
.distinct()
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 1
i = 2
DistinctUntilChanged
distinctUntilChanged()与distinct()相类似,不过distinctUntilChanged()是判断当前发射的值与前一个数据是否相同,在实际中,可以假设情形比如说UI根据获取到的数据不同更新自身UI,但是如果数据内容并没有发生改变,出于不浪费资源的目的,就不要发射数据。
public static void main(String... args) {
Observable.just(1,2,2)
.distinct()
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 1
i = 2
First
first()从Observable中只发射第一个元素,或者添加参数first(Fun1)只发送符合条件的第一个数据项。
public static void main(String... args) {
Observable.just(1,2,2)
.first()
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 1
public static void main(String... args) {
Observable.just(1,2,2)
.first(new Func1() {
@Override
public Boolean call(Integer integer) {
return integer == 2;
}
})
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 2
Last
first()从Observable中只发射最后一个元素,或者添加参数first(Fun1)只发送符合条件的最后一个数据项。代码参考First。
Skip
skip(int)可以让我们忽略Observable前n个元素,而直接跳过这n个元素发射后面的元素。
public static void main(String... args) {
Observable.just(1,2,2)
.skip(2)
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 2
SkipLast
skipLast(int)则是忽略后n个元素的发射。
ElementAt
现在我们有了控制前后的元素过滤规则,那么自然会有一个问题,如果我只想要观测序列其中的一个元素该怎么办呢,那么elementAt(int)就能实现。elementAt(int)
用来获取元素Observable发射的事件序列中的第n项数据,并当做唯一的数据发射出去。
public static void main(String... args) {
Observable.just(1,2,3)
.elementAt(2)
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 3
同时还有一个拓展方法,如果想查找第六个元素,但是可观测序列只有三个元素怎么办,可以用elementAtOrDefault(int index, T defaultValue)
,在第二个参数传入一个默认值。
Sample
假如我们有一个温度传感器,每秒钟都会发射一次室内温度,然后UI根据温度变化而更新,但是有一个问题,我们认为每秒钟就获取一次数据并更新相当的浪费资源,再说温度也不一定变化这么快,那么我们就需要一个小小的发射间隔。sample()就能帮我们做到这一点,在Observable后面加一个sample(),将创建一个新的观测序列,并且它会在指定的时间间隔里由Observable发射最近的一次数值。
public static void main(String... args) {
Observable observable = Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
for (int i = 0; i <= 50; i++) {
if (i % 10 ==0){
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
subscriber.onNext(i);
}
}
});
observable.sample(2, TimeUnit.SECONDS)
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
先打印结果:
i = 9
i = 19
i = 29
i = 39
i = 49
分析:这里我们先创建了一个Observable,主要就是一个for循环,依次发射0~50,为了验证方便呢,就加了一个判断,如果发射的是整数就线程休眠5s,为什么要这样干呢,你想cpu多快啊,才50个数不是一滋溜就发射完了么,那之后通过sample(2, TimeUnit.SECONDS)
设置的2s发射一个最近的值不是只有最后的一个值了么,打印的结果也就达不到验证的目的了呀。这里再附上一张图:
如果我们想让它定时发射第一个元素而不是最近的一个元素,我们可以使用throttleFirst()
。
Timeout
有的时候我们在规定的时间内必须要有一个数据,就上文的温度传感器来说,我们想让它每隔两秒至少发射一个,那么我们就可以用timeout
函数来监听观测序列,如果在我们设定的时间内没有得到一个值就发射一个错误。
public static void main(String... args) {
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
for (int i = 0; i < 50; i++) {
if (i % 10 == 0){
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
subscriber.onNext(i);
}
}
})
.timeout(2, TimeUnit.SECONDS)
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
System.out.println("Timeout error");
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
Timeout error
可以看到,我们通过timeout(2, TimeUnit.SECONDS)
设置了2s的时间限制,而在Observable中让线程休眠了2s,那么触发了Timeout,发射了一个错误。
Debounce
debounce()过滤掉了由Observable发射的速率过快的数据,如果在一个指定的时间间隔过去了仍旧没有发射一个,那么它将发射最后的那个。
public static void main(String... args) {
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
for (int i = 0; i <= 50; i++) {
if (i % 10 == 0){
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
subscriber.onNext(i);
}
}
})
.debounce(2 , TimeUnit.SECONDS)
.subscribe(new Observer() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(Integer integer) {
System.out.println("i = " + integer);
}
});
}
打印结果:
i = 9
i = 19
i = 29
i = 39
i = 49
从打印的结果来看,与之前的sample
一般无二,但是要理解意义的不同,sample
是在一条可观测序列中,选择指定时间段要发射的元素发射出来,而debounce
是指一段时间内没有新数据发射,那么就发射最后的那一个。