RxJava过滤操作符实例
来源:互联网 发布:淘宝店铺免费模版 编辑:程序博客网 时间:2024/06/09 21:07
过滤操作符
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
- RxJava过滤操作符实例
- RxJava-过滤操作符
- RxJava过滤操作符
- Rxjava 过滤操作符
- RxJava过滤操作符 filter
- RxJava过滤操作符 debounce
- RxJava 过滤操作符 ofType
- RxJava 过滤操作符 ignoreElements
- RxJava 过滤操作符 sample
- RxJava之过滤操作符
- RxJava操作符(3)-过滤
- RxJava—过滤操作符
- RxJava----操作符:过滤操作符
- RxJava操作符(04-过滤操作)
- RxJava 过滤操作符 distinct和elementAt
- RxJava 过滤操作符 first last single
- RxJava操作符总结之过滤
- RxJava系列4(过滤操作符)
- 144.Interleaving Positive and Negative Numbers-交错正负数(中等题)
- Django笔记(1)新建项目
- 习题15--读取文件
- orcal安装过程中遇到问题: 未找到文件
- YESLAB阿彭版CCNP Security ASA 防火墙精讲视频课程
- RxJava过滤操作符实例
- 概述
- 麦子学院自动化测试-selenium视频教程
- SQL 数据库 学习 022 查询-05 top 的用法 --- 最前面的若干个记录
- win7配置caffe的错误及解决方法
- JavaScript学习笔记(9)
- [kuangbin带你飞]专题五 并查集 F POJ 1417
- Leetcode62: Unique Paths
- hduoj 1312