即日起在codingBlog上分享您的技术经验即可获得积分,积分可兑换现金哦。

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

编程语言 F___e 11℃ 0评论
本文目录
[隐藏]

1.操作符

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开始的。

() {                     @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!" data-snippet-id="ext.384ec7640ac6928c0e3aa121b76bc431" data-snippet-saved="false">Observable.just(1,2,3,4,5,6).elementAt(2)
          .subscribe(
                new Action1() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1() {
                    @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() {
    @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条数据

 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" data-snippet-id="ext.33877185045339dc4a3f30c586319657" data-snippet-saved="false">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 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 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() : 事件消费的线程

转载请注明:CodingBlog » 最近收集的一些RXjava的操作符

喜欢 (0)or分享 (0)
发表我的评论
取消评论

*

表情