过滤操作符
filter
符合某种规则的Observable才会向下传递,例子
Observable.range(100,10).filter(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer>105;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
}
});
上面的Subscriber只会得到大于105的数值
first
只发射第一项,或者是满足条件的第一项,两个例子
Observable.range(100,5).first();// 发射100
Observable.range(100,5).first(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer>102;//发射103
}
});
Debounce
当操作太频繁的时候,在第N个节点发射之前会忽略钱N-1个节点,比如我们的Edittext去seach的时候,可能需要过滤前多少秒的操作只是需要后续的操作。简单点来说,就是,他需要的是在某个时间点之后的结果,在这个时间点之前的结果他会忽略不再发送给下一级。例子:
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(100*i);
}
subscriber.onCompleted();
} catch (InterruptedException e) {
e.printStackTrace();
subscriber.onError(e);
}
}
}).subscribeOn(Schedulers.newThread())
.debounce(500, TimeUnit.MILLISECONDS).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
Log.i(TAG, "OnComplete");
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "Throwable");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "integer == "+integer.toString());
}
});
输出就是6.7.8.9.10
总结就是debounce操作符就是类似一个控制入口,他是有一个门卡的,门卡一般是时间,在这之前的忽略,之后的可以进入
例子是来自 Android RxJava使用介绍(三) RxJava的操作符
其中,还有一个throttleWithTimeout操作符,他的底层也是通过调用debounce操作符完成的,作用类似。但是debounce比她在、多了一个功能就是可以通过函数来进行限流操作。例子如下:
Observable.just(1, 2, 3, 4, 5).debounce(new Func1<Integer, Observable<Integer>>() {
@Override
public Observable<Integer> call(Integer integer) {
return Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> subscriber) {
if (integer % 2 == 0 && !subscriber.isUnsubscribed()) {
subscriber.onNext(integer);
subscriber.onCompleted();
}
}
});
}
}).subscribeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString() + "==integer");
}
});
结果输出是2.4.5。5为什么在其中?因为,在debounce操作符中,最后一个Observable,在被调用onComplete之前的时间间隔内被调用,那么他也会被传递到下一级。
Distinct
只允许没有发射过的数据发射,可以定义过滤规则,例子
Observable.range(1,5).distinct(new Func1<Integer, String>() {
@Override
public String call(Integer integer) {
if(integer<=2) return "1";// 定义过滤规则
return "2";
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString());
}
});
Observable.just(1,2,3,1,2).distinct().subscribe(new Action1<Integer>() { // 使用默认规则
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString());
}
});
输出
09-02 00:32:45.009 4762-4762/? I/RxJavaTest: 1==自定义
09-02 00:32:45.009 4762-4762/? I/RxJavaTest: 3==自定义
09-02 00:32:45.009 4762-4762/? I/RxJavaTest: 1===系统
09-02 00:32:45.009 4762-4762/? I/RxJavaTest: 2===系统
09-02 00:32:45.009 4762-4762/? I/RxJavaTest: 3===系统
elementAt
某一位置的元素可以发射,需要需要越界的问题,他是从0开始计算的例子
Observable.range(10,10).elementAt(9).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
}
});
last
最后一个或者满足条件的最后一个,跟first相反,例子
Observable.range(10,5).last();
Observable.range(10,5).last(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
return integer>13;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString()+"===last");
}
});
skip
跳过前N项,从第N+1开始发射,例子
Observable.range(10,20).skip(10);
这个例子是丢弃了10~29中的10~19,保留20~29,还有两个重载的方法
skip(long,TimeUnit));// 跳过前long时间的Observable,发射之后的
skip(long,TimeUnit,Scheduler));//可以定义调度器
结果是14,两个都是
skipLast
不发射后n项数据,跟skip相反,例如
Observable.range(1,10).skipLast(3).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString() + "==skip");
}
});
输出:1,2,3,4,5,6,7
take
只取前n项数据,例如有10项数据,那么take(4),就是只是圈前4项数据,例如
Observable.range(10,10).take(5).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString() + "==take");
}
});
结果是:10,11,12,13,14
taskLast
只发射最后n项数据,比如有10项数据,taskLast(3),则是只发射最后3项数据,例子:
Observable.range(9,5).takeLast(2).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString() + "==integer");
}
});
输出:12和13
需要注意的是他是一个线程同步的,他可能造成Observable发射延迟,因为他只有过滤掉前面的数据才会轮到后面,然后后面的数据才会发射。
重构的方法有:
takeLast(final int count) //发射后面n个数据,n大于数据全部的时候则发射全部n小于0报异常
takeLast(int count, long time, TimeUnit unit)// 发射最后给定时间的n个数据
takeLast(int count, long time, TimeUnit unit, Scheduler scheduler)
takeLast(long time, TimeUnit unit, Scheduler scheduler)//发射最后给定时间的全部数据,可以指定调度器
takeLast(long time, TimeUnit unit)
同时,他还有一个变形,takeLastBuffer*,takeLast是一个一个数据源返回,但是takeLastBuffer是以List的形式返回,例如:
Observable.range(20,10).takeLastBuffer(5).subscribe(new Action1<List<Integer>>() {
@Override
public void call(List<Integer> integers) {
Log.i(TAG, integers.toString() + "==integer");
}
});
ignoreElements
忽略所有的元素,只是发射结束事件或者是错误时间,例如
Observable.range(10,10).ignoreElements().subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
Log.i(TAG, "onCompleted");
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, integer.toString() + "==ignoreElements");
}
});
last
只发射最后的一项数据,忽略前面n项数据,例如
Observable.range(10,10).last().subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString() + "==last");
}
});
结果是:19
还有一个last(Func1)的重载函数,他可以规定那个才是last,比如
Observable.range(10,10).last(new Func1<Integer, Boolean>() {
@Override
public Boolean call(Integer integer) {
Log.i(TAG, integer.toString() + "==last");
return integer == 14;
}
}).subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
Log.i(TAG, integer.toString() + "==last func");
}
});
在subscribe里面输出的就是14而不是19,还有一个相似函数是:lastOrDefault(T),他会在Observable没有发射任何数据的时候发射默认值T。
sample操作符,
他是在某一段时间内采集过去发射的旧数据再次发射,比如:
Observable.interval(1,TimeUnit.SECONDS).sample(2,TimeUnit.SECONDS).subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.i(TAG, aLong.toString() + "==sample ");
}
});
interval创造一个Observable之后每个1s发射一个新数据,然后sample会在2s重复的去采集已经发射的旧数据再次发射,输出的结果是:0,2,4,6…
它默认开启新线程,我们也可指线程给sample运行
sample例子来自RxJava 过滤操作符 sample