Rxjava基本操作符详解

最新推荐文章于 2022-09-18 22:49:05 发布

hoko

最新推荐文章于 2022-09-18 22:49:05 发布

阅读量283

点赞数

分类专栏： Rxjava

本文链接：https://blog.csdn.net/qq_15327675/article/details/83895457

版权

Rxjava 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

Rxjava中的最基本的操作符有如下几个:

1.基本创建操作符 create()

Observable<Integer> ob = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "subscribe:");
                    e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        });

        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: " + d.isDisposed());
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        };


        ob.subscribe(observer);

        //基于事件流的链式调用
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "subscribe: ");
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: "+integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

2.快速创建操作符

2.1 just(T... t)

//快速创建操作符just
        //相当于ObservableEmitter依次调用onNext(1 - 10) onComplete()
        //just最多只能发送10个参数
        Observable.just(1,2,3,4,5,6,7,8,9,10).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: 开始采用subscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: "+ integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

2.2 fromArray(T[] t) / fromIterable(Iterable it)

//快速创建操作符fromArray()/ fromIterable()
        Observable.fromArray(new Integer[]{1,2,3,4,5,6,7,8,9,10}).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: 开始数组遍历");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: 数组遍历结束");
            }
        });


        ArrayList list = new ArrayList();
        for (int i = 0; i < 100; i++) {
            list.add(i);
        }
        Observable.fromIterable(list).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: 开始集合遍历");
            }

            @Override
            public void onNext(Integer i) {
                Log.d(TAG, "onNext: " + i);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: 集合遍历出现异常");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: 集合遍历结束");
            }
        });

2.3 一些额外的特殊的快速创建操作符empty()/ error() / never():

//快速创建中的特殊的操作符
        //empty() 该创建符创建的被观察者直接发送complete事件通知完成 即观察者直接调用onComplete()方法
       Observable.empty().subscribe(new Observer<Object>() {
           @Override
           public void onSubscribe(Disposable d) {
               Log.d(TAG, "onSubscribe: ");
           }

           @Override
           public void onNext(Object o) {
               Log.d(TAG, "onNext: " + o.toString());
           }

           @Override
           public void onError(Throwable e) {
               Log.d(TAG, "onError: ");
           }

           @Override
           public void onComplete() {
               Log.d(TAG, "onComplete: ");
           }
       });

        //error()操作符创建的被观察者只会产生error事件 因此观察者只会调用onError进行响应
        Observable.error(new RuntimeException("只产生error事件，观察者只调用onError()进行响应")).subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Object o) {
                Log.d(TAG, "onNext: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

        //never()该创建符创建的被观察者不会发送任何的事件 因此观察者也不会调用任何的响应事件的方法
        Observable.never().subscribe(new Observer<Object>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

            @Override
            public void onNext(Object o) {
                Log.d(TAG, "onNext: ");
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

3.延迟创建操作符

一般的使用场景:

定时操作：在经过了x秒后，需要自动执行y操作

周期性操作：每隔x秒后，需要自动执行y操作

3.1 defer()操作符

private int i = 10;
    private void quickCreateDefer() {

        //延迟创建操作符defer():作用是直到有观察者Observer订阅时才动态的创建被观察者Observable对象 以及才发送事件
        //在每次订阅后都会得到一个最新的刚刚创建的Observable对象，这样可以确保Observable里面的数据是最新的
        //应用场景：动态的创建被观察者对象(Observable) 获取最新的Observable对象里面的数据
        i = 15;
        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<Integer>>() {
            @Override
            public ObservableSource<Integer> call() throws Exception {
                //抽象类Observable实现了ObservableSource接口
                //在call方法中返回我们最新创建的被观察者Observable对象
                return Observable.just(i);
            }
        });

        Observable<Integer> just = Observable.just(i);
        i = 20;

        observable.subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: 开始采用sunscribe连接");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: ");
            }
        });

        just.subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "-------------------------------------------------------------------------------------");
                Log.d(TAG, "onSubscribe: just");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "onNext: just " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: just");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: just");
            }
        });
    }

打印结果：

通过结果可以看到defer()延迟创建符是在只有发生了订阅时候才去动态的创建被观察者对象,而常规的快速创建符是不管有没有发生订阅就会马上创建被观察者Observable对象

3.2 timer()操作符

//timer()创建符
        //timer()操作符也是快速创建一个被观察者Observable对象
        //timer()发送事件的特点：延迟指定时间后，发送1个数值0（Long类型）
        //本质 = 延迟指定时间后，调用一次 onNext(0)
        //应用场景：延迟制定时间发送一个事件0, 一般用于检测

        //注意：Timer操作符默认是运行在一个新的线程上也可以通过第三个参数来自定义线程调度器(timer(long,timeunit,scheduler)
        Observable<Long> observable = Observable.timer(2, TimeUnit.SECONDS);
        //调度Timer创建符运行在安卓 主线程上
        Observable<Long> observableMainThread = Observable.timer(2, TimeUnit.SECONDS, AndroidSchedulers.mainThread());

        observable.subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "onNext: " + aLong + "thread " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread " + Thread.currentThread().getName());
            }
        });

        observableMainThread.subscribe(new Consumer<Long>() {
            @Override
            public void accept(@NonNull Long aLong) throws Exception {
                Log.d(TAG, "accept: " + aLong + "thread " + Thread.currentThread().getName());
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(@NonNull Throwable throwable) throws Exception {
                Log.d(TAG, "accept: " + "thread " + Thread.currentThread().getName());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "run: complete  thread " + Thread.currentThread().getName());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(@NonNull Disposable disposable) throws Exception {
                Log.d(TAG, "accept: onsubscribe thread " + Thread.currentThread().getName());
            }
        });

运行结果:

3.3 interval()创建符

 //interval()创建符
        //interval()也是快速创建一个Obervable被观察者对象
        //发送事件的特点是可以指定第一个发送事件的延迟时间以及后续每次发送事件的间隔时间
        //发送的事件序列：从0开始 无限递增1的整数序列
        //延迟2秒 每隔1秒发送从0开始无限递增的整数序列
        Observable<Long> observable = Observable.interval(2, 1, TimeUnit.SECONDS);
        //interval创建符默认也是运行Computation线程上,我们也可以自己指定它的运行线程
        Observable<Long> observableMainThread = Observable.interval(2, 1, TimeUnit.SECONDS, AndroidSchedulers.mainThread());
        observable.subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "onNext: " + aLong + " thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread : " + Thread.currentThread().getName());
            }
        });

运行结果:

3.4 intervalRange()操作符

//intervalRange()创建符
        //intervalRnage创建符也是快速创建一个被观察者Observable对象它和interval()创建符不同的是
        //intervalRnage()可以指定发送事件的起始值(interval()的起始值默认是从0开始的)
        //intervalRnage()可以指定发送事件的数量(interval()不能指定发送的事件数量无限的往下发送事件)
        //其它的和interval()创建符一样
        //从5开始发送10个事件 第一次发送延迟2秒 之后每次间隔1秒发送事件
        Observable<Long> observable = Observable.intervalRange(5, 10, 2, 1, TimeUnit.SECONDS);
        //intervalRange()创建的默认也是执行在computation线程上的我们可以手动指定其运行的线程
        Observable<Long> observableMainThread = Observable.intervalRange(3, 10, 2, 1, TimeUnit.SECONDS, AndroidSchedulers.mainThread());

        observable.subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "onNext: " + aLong + " thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread : " + Thread.currentThread().getName());
            }
        });

运行结果:

3.5 range() / rangeLong()操作符

//range() 和 rangeLong()创建符
        //类似intervalRnage()创建符，区别是intervalRange可以指定第一次延迟发送事件的时间以及每次发送事件之间的间隔时间
        //而range()和rangeLong()创建符是不能指定时间的 是依次全部没有延迟时间的发送事件
        //而range()和rangeLong()操作符之间的区别仅仅是发送事件的数值的类型不同一个是int 一个是long类型
        //没有单独运行到单独的线程中
        Observable.range(100,4).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Integer aLong) {
                Log.d(TAG, "onNext: " + aLong + " thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread : " + Thread.currentThread().getName());
            }
        });
        Log.d(TAG, "--------------------------------------------------------------------------------");
        Observable.rangeLong(100,4).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onNext(Long aLong) {
                Log.d(TAG, "onNext: " + aLong + " thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError: thread : " + Thread.currentThread().getName());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete: thread : " + Thread.currentThread().getName());
            }
        });

运行结果:

由此我们总结出rxjava创建操作符的常见类型以及作用:

类型		作用	备注	应用场景	实际开发需求
基本创建	create()	完整创建一个被观察者对象(Observable)	rxjava中创建被观察者Observable对象的最基本的操作符	完整快速创建被观察者数组/集合遍历	网络请求轮询
快速创建	just()	快速创建直接发送传入的事件（onNext() onComplete())	最多只能发送10个参数应用场景:快速创建被观察者对象以及发送10个以下数量的事件
	fromArray()	快速创建直接依次发送传入的数组数据(onNext() onComplete())	可发送10个以上数量的事件（数组形式)
	fromIterable()	快速创建直接依次发送传入的集合数据 (onNext() onComplete())	可发送10个以上数量的事件（集合形式)
	empty()	快速创建后直接发送complete事件直接通知完成调用观察者的onComplete()
	error()	快速创建后直接发送error事件直接通知异常调用观察者的onError()
	never()	快速创建被观察者Observable对象但是不发送任何事件观察者不会做出任何的响应
延迟创建	defer()	延迟创建直到有观察者Observer订阅时才动态的创建被观察者Observable对象以及发送事件	通过Observable静态工厂方法来创建Observable对象每次创建后都会得到一个最新的Observable对象，这样可以保证每次创建的Observable对象中的数据是最新的	动态创建被观察者Observable对象获取最新的Observable对象的数据
	timer()	快速创建后延迟指定时间发送一个数值0(Long类型)的事件有线程切换	本质= 延迟指定时间后调用一次onNext(0)	延迟指定时间发送一个事件0 一般用于检测
	interval()	快速创建后每隔指定的时间就发送事件有线程切换	从0开始发送无限递增的事件序列	定时操作周期性操作
	intervalRnage()	快速创建后每隔指定的时间就发送事件但是可以指定发送事件的起始值和数量有线程切换	发送从0开始无限递增的事件序列和interval()不同的是可以指定发送事件的起始值和数量
	range()	快速创建连续发送一个指定的事件但是可以指定发送事件的起始值和数量	发送从0开始无限递增的事件序列（整数）和intervalRange()类似不同的是不能延迟发送是立即发送事件序列
	rangeLong()	和Rnage()一样只是发送的事件的值是long类型的

hoko

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Rxjava基本操作符详解

Rxjava中的最基本的操作符有如下几个:1.基本创建操作符 create()Observable&lt;Integer&gt; ob = Observable.create(new ObservableOnSubscribe&lt;Integer&gt;() { @Override public void subscribe(Obse...
复制链接

扫一扫