最近收集的一些RXjava的操作符

最新推荐文章于 2024-04-14 18:01:38 发布

F___e

最新推荐文章于 2024-04-14 18:01:38 发布

阅读量288

点赞数 1

本文链接：https://blog.csdn.net/F___e/article/details/72901053

版权

操作符

create操作符所有创建型操作符的“根”，也就是说其他创建型操作符最后都是通过create操作符来创建Observable的

from操作符是把其他类型的对象和数据类型转化成Observable

just操作符把其他类型的对象和数据类型转化成Observable，它和from操作符很像，只是方法的参数有所差别

defer操作符是直到有订阅者订阅时，才通过Observable的工厂方法创建Observable并执行，defer操作符能够保证Observable的状态是最新的

timer操作符是创建一串连续的数字，产生这些数字的时间间隔是一定的；这里有两种情况：一种是隔一段时间产生一个数字，然后就结束，可以理解为延迟产生数字。一种是每隔一段时间就产生一个数字，没有结束符，也就是是可以产生无限个连续的数字

interval操作符是每隔一段时间就产生一个数字，这些数字从0开始，一次递增1直至无穷大；interval操作符的实现效果跟上面的timer操作符的第二种情形一样

range操作符创建一组在从n开始，个数为m的连续数字，比如range(3,10)，就是创建3、4、5…12的一组数字

repeat操作符 repeat操作符是对某一个Observable，重复产生多次结果

repeatWhen操作符是对某一个Observable，有条件地重新订阅从而产生多次结果

distinct操作符 distinct操作符对源Observable产生的结果进行过滤，把重复的结果过滤掉，只输出不重复的结果给订阅者，非常类似于SQL里的distinct关键字

debounce操作符对源Observable每产生一个结果后，如果在规定的间隔时间内没有别的结果产生，则把这个结果提交给订阅者处理，否则忽略该结果。

elementAt操作符在源Observable产生的结果中，仅仅把指定索引的结果提交给订阅者，索引是从0开始的。

Observable.just(1,2,3,4,5,6).elementAt(2)
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("completed!");
                    }
                });
运行结果如下： Next:3 completed!

filter操作符对源Observable产生的结果按照指定条件进行过滤，只有满足条件的结果才会提交给订阅者

ofType操作符类似于filter操作符，区别在于ofType操作符是按照类型对结果进Observable.just(1, “hello world”, true, 200L, 0.23f)
.ofType(Float.class)
.subscribe(new Subscriber() {
@Override
public void onNext(Object item) {
System.out.println(“Next: ” + item);
}
@Override
public void onError(Throwable error) {
System.err.println(“Error: ” + error.getMessage());
}
@Override
public void onCompleted() {
System.out.println(“Sequence complete.”);
}
});

运行结果如下： Next: 0.23 Sequence complete.
firstst操作符是把源Observable产生的结果的第一个提交给订阅者,first操作符可以使用elementAt(0)和take(1)替代

single操作符是对源Observable的结果进行判断，如果产生的结果满足指定条件的数量不为1，则抛出异常，否则把满足条件的结果提交给订阅者

last操作符源Observable产生的结果的最后一个提交给订阅者，last操作符可以使用takeLast(1)替代

ignoreElements操作符忽略所有源Observable产生的结果，只把Observable的onCompleted和onError事件通知给订阅者。

ignoreElements操作符适用于不太关心Observable产生的结果，只是在Observable结束时(onCompleted)或者出现错误时能够收到通知

sample操作符定期扫描源Observable产生的结果，在指定的时间间隔范围内对源Observable产生的结果进行采样

skip操作符对源Observable产生的结果，跳过前面n个不进行处理，而把后面的结果提交给订阅者处理

skipLast操作符对源Observable产生的结果，忽略Observable最后产生的n个结果，而把前面产生的结果提交给订阅者处理，值得注意的是，skipLast操作符提交满足条件的结果给订阅者是存在延迟效果的

take操作符把源Observable产生的结果，提取前面的n个提交给订阅者，而忽略后面的结果

takeFirst操作符类似于take操作符，同时也类似于first操作符，都是获取源Observable产生的结果列表中符合指定条件的前一个或多个，与first操作符不同的是，first操作符如果获取不到数据，则会抛出NoSuchElementException异常，而takeFirst则会返回一个空的Observable，该Observable只有onCompleted通知而没有onNext通知

takeLast操作符把源Observable产生的结果的后n项提交给订阅者，提交时机是Observable发布onCompleted通知之时

buffer操作符周期性地收集源Observable产生的结果到列表中，并把这个列表提交给订阅者，订阅者处理后，清空buffer列表，同时接收下一次收集的结果并提交给订阅者，周而复始。需要注意的是，一旦源Observable在产生结果的过程中出现异常，即使buffer已经存在收集到的结果，订阅者也会马上收到这个异常，并结束整个过程。

flatMap操作符是把Observable产生的结果转换成多个Observable，然后把这多个Observable“扁平化”成一个Observable，并依次提交产生的结果给订阅者。flatMap操作符通过传入一个函数作为参数转换源Observable，在这个函数中，你可以自定义转换规则，最后在这个函数中返回一个新的Observable，然后flatMap操作符通过合并这些Observable结果成一个Observable，并依次提交结果给订阅者。

concatMap操作符与flatMap操作符类似，都是把Observable产生的结果转换成多个Observable，然后把这多个Observable“扁平化”成一个Observable，并依次提交产生的结果给订阅者。与flatMap操作符不同的是，concatMap操作符在处理产生的Observable时，采用的是“连接(concat)”的方式，而不是“合并(merge)”的方式，这就能保证产生结果的顺序性，也就是说提交给订阅者的结果是按照顺序提交的，不会存在交叉的情况。

groupBy操作符 groupBy操作符是对源Observable产生的结果进行分组，形成一个类型为GroupedObservable的结果集，GroupedObservable中存在一个方法为getKey()，可以通过该方法获取结果集的Key值（类似于HashMap的key)。值得注意的是，由于结果集中的GroupedObservable是把分组结果缓存起来，如果对每一个GroupedObservable不进行处理（既不订阅执行也不对其进行别的操作符运算），就有可能出现内存泄露。因此，如果你对某个GroupedObservable不进行处理，最好是对其使用操作符take(0)处理。

map操作符 map操作符是把源Observable产生的结果，通过映射规则转换成另一个结果集，并提交给订阅者进行处理。

cast操作符 cast操作符类似于map操作符，不同的地方在于map操作符可以通过自定义规则，把一个值A1变成另一个值A2，A1和A2的类型可以一样也可以不一样；而cast操作符主要是做类型转换的，传入参数为类型class，如果源Observable产生的结果不能转成指定的class，则会抛出ClassCastException运行时异常。

scan操作符 scan操作符通过遍历源Observable产生的结果，依次对每一个结果项按照指定规则进行运算，计算后的结果作为下一个迭代项参数，每一次迭代项都会把计算结果输出给订阅者。

window操作符 window操作符非常类似于buffer操作符，区别在于buffer操作符产生的结果是一个List缓存，而window操作符产生的结果是一个Observable，订阅者可以对这个结果Observable重新进行订阅处理。

Combining Observables(Observable的组合操作符)

combineLatest操作符把两个Observable产生的结果进行合并，合并的结果组成一个新的Observable。这两个Observable中任意一个Observable产生的结果，都和另一个Observable最后产生的结果，按照一定的规则进行合并

merge操作符，合并观察对象

filter 过滤操作符的使用

Observable observable = Observable.just( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) ;
observable.filter(new Func1<Integer , Boolean>() {
    @Override
    public Boolean call(Integer o) {
        //数据大于4的时候才会被发送
        return o > 4 ;
    }
})
        .subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println( "filter-- " +  o );
            }
        })   ;

take ：取前n个数据
takeLast：取后n个数据
first 只发送第一个数据
last 只发送最后一个数据
skip() 跳过前n个数据发送后面的数据
skipLast() 跳过最后n个数据，发送前面的数据

elementAt elementAt() 发送数据序列中第n个数据，序列号从0开始 //如果该序号大于数据序列中的最大序列号，则会抛出异常，程序崩溃// 以在用elementAt操作符的时候，要注意判断发送的数据序列号是否越界

elementAtOrDefault( int n , Object default ) 发送数据序列中第n个数据，序列号从0开始。如果序列中没有该序列号，则发送默认值

startWith() 插入数据,startWith 数据序列的开头插入一条指定的项 , 最多插入9条数据

Observable observable = Observable.just( "aa" , "bb" , "cc" ) ;
observable
        .startWith( "11" , "22" )
        .subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println( "startWith-- " + o );
            }
        }) ;

//插入Observable对象
List<String> list = new ArrayList<>() ;
list.add( "ww" ) ;
list.add( "tt" ) ;
observable.startWith( Observable.from( list ))
        .subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println( "startWith2 -- " + o );
            }
        }) ;
//输出结果   11，22，aa,bb,cc,ww,tt,aa,bb,cc

delay操作符，延迟数据发送

Observable<String> observable = Observable.just( "1" , "2" , "3" , "4" , "5" , "6" , "7" , "8" ) ;
 //延迟数据发射的时间，仅仅延时一次，也就是发射第一个数据前延时。发射后面的数据不延时
       observable.delay( 3 , TimeUnit.SECONDS )  //延迟3秒钟
               .subscribe(new Action1() {
                   @Override
                   public void call(Object o) {
                       System.out.println("delay-- " + o);
                   }
               }) ;

interval 轮询操作符，循环发送数据，数据从0开始递增

//参数一：延迟时间  参数二：间隔时间  参数三：时间颗粒度
        Observable observable =  Observable.interval(3000, 3000, TimeUnit.MILLISECONDS) ;
        subscription = observable.subscribe(new Action1() {
            @Override
            public void call(Object o) {
                System.out.println( "interval-  " + o );
            }
        })  ;

doOnNext() 操作符，在每次 OnNext() 方法被调用前执行

Buffer( int n ) 把n个数据打成一个list包，然后再次发送。
Buffer( int n , int skip) 把n个数据打成一个list包，然后跳过第skip个数据。
使用场景：一个按钮每点击3次，弹出一个toast

throttleFirst 操作符在一段时间内，只取第一个事件，然后其他事件都丢弃。
使用场景：1、button按钮防抖操作，防连续点击 2、百度关键词联想，在一段时间内只联想一次，防止频繁请求服务器

distinct 过滤重复的数据
distinctUntilChanged() 过滤连续重复的数据
debounce() 一段时间内没有变化，就会发送一个数据。
使用场景：百度关键词联想提示。在输入的过程中是不会从服务器拉数据的。当输入结束后，在400毫秒没有输入就会去获取数据。避免了，多次请求给服务器带来的压力.

doOnSubscribe() 使用场景：可以在事件发出之前做一些初始化的工作，比如弹出进度条等等
注意：
a、doOnSubscribe() 默认运行在事件产生的线程里面，然而事件产生的线程一般都会运行在 io 线程里。那么这个时候做一些，更新UI的操作，是线程不安全的。所以如果事件产生的线程是io线程，但是我们又要在doOnSubscribe() 更新UI ，这时候就需要线程切换。
b、如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。
c、 subscribeOn() 事件产生的线程； observeOn() : 事件消费的线程