RxJava基础学习4-功能操作符

最新推荐文章于 2024-05-20 13:55:55 发布
最新推荐文章于 2024-05-20 13:55:55 发布
阅读量535 收藏 2
点赞数
分类专栏： Android 文章标签： rxjava 学习 android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010090644/article/details/124709208
版权

1、subscribe() 操作符

连接 被观察者 和 观察者

//创建被观察者
        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) throws Exception {
                emitter.onNext("事件1");
                emitter.onNext("事件2");
            }
        });

        //创建观察者
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG + "subscribe", "开始连接");
            }

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

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };

        //通过subscribe 进行 被观察者(Observable)与观察者(Observer)的连接
        observable.subscribe(observer);
2022-05-11 14:11:03.442 26655-26655/? D/MainActivitysubscribe: 开始连接
2022-05-11 14:11:03.442 26655-26655/? D/MainActivitysubscribe: 收到:事件1
2022-05-11 14:11:03.442 26655-26655/? D/MainActivitysubscribe: 收到:事件2

2、delay() 操作符

     * 延迟发送事件
     * 
     * delay有多个重载方法：
     * delay(long delay,TimeUnit unit) :指定延迟时间。 参数一：时间 ； 参数二：时间单位
     * delay(long delay, TimeUnit unit, Scheduler scheduler)  指定延迟时间&线程调度器。参数一：时间 ； 参数二：时间单位；参数三： 线程调度器
     * delay(long delay, TimeUnit unit, boolean delayError)  指定延迟时间&线程调度器。参数一：时间 ； 参数二：时间单位；参数三： 是否错误延迟
     * delay(long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)  指定延迟时间&线程调度器&错误延迟。参数一：时间 ； 参数二：时间单位；
     * 参数三： 线程调度器; 参数四：是否错误延迟(若中间发生错误，是否如常执行，执行完在执行onError())
 

 Observable.just(11,22,33,24,35)
                .delay(2, TimeUnit.SECONDS)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "delay", String.valueOf(integer));
                    }
                });
2022-05-11 14:26:17.733 27641-27641/com.app.empty D/MainActivitydelay: start
2022-05-11 14:26:22.737 27641-27707/com.app.empty D/MainActivitydelay: 11
2022-05-11 14:26:22.737 27641-27707/com.app.empty D/MainActivitydelay: 22
2022-05-11 14:26:22.738 27641-27707/com.app.empty D/MainActivitydelay: 33
2022-05-11 14:26:22.738 27641-27707/com.app.empty D/MainActivitydelay: 24
2022-05-11 14:26:22.738 27641-27707/com.app.empty D/MainActivitydelay: 35

3、do 系列操作符
   

     * 在事件发送&接收的整个周期过程中进行操作。
     * 
     * 如发送事件前的操作，发送事件后的回调请求
     * 
     * do系列操作符包含以下：
     * 
     * doOnEach() :当Observable每发送一次事件就会调用一次(包含onNext()，onError()，onComplete())
     * doOnNext(): 执行 onNext()前调用
     * doAfterNext()： 执行onNext()后调用
     * doOnComplete()：执行onComplete()前调用
     * doOnError():执行 onError()前调用
     * doOnTerminate(): 执行终止(无论正常发送完毕/异常终止)
     * doFinally(): 最后执行
     * doOnSubscribe() ：观察者订阅是调用
     * doOnUnScbscribe()： 观察者取消订阅时调用
 

 Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onNext(3);
                        emitter.onError(new NullPointerException());
                    }
                })
                .doOnEach(new Consumer<Notification<Integer>>() {
                    @Override
                    public void accept(Notification<Integer> integerNotification) throws Exception {
                        Log.d(TAG + "doOnEach", "doOnEach:  " + String.valueOf(integerNotification.getValue()));
                    }
                })
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "doOnNext", "doOnNext:  " + String.valueOf(integer));
                    }
                })
                .doAfterNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "doAfterNext", "doAfterNext:  " + String.valueOf(integer));
                    }
                })
                .doOnComplete(new Action() {
                    @SuppressLint("LongLogTag")
                    @Override
                    public void run() throws Exception {
                        Log.d(TAG + "doOnComplete", "doOnComplete");
                    }
                })
                .doOnError(new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.d(TAG + "doOnError", "doOnError");
                    }
                })
                .doOnTerminate(new Action() {
                    @SuppressLint("LongLogTag")
                    @Override
                    public void run() throws Exception {
                        Log.d(TAG + "doOnTerminate", "doOnTerminate");
                    }
                })
                .doAfterTerminate(new Action() {
                    @SuppressLint("LongLogTag")
                    @Override
                    public void run() throws Exception {
                        Log.d(TAG + "doAfterTermi", "doAfterTerminate");
                    }
                })
                .doOnSubscribe(new Consumer<Disposable>() {
                    @SuppressLint("LongLogTag")
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        Log.d(TAG + "doOnSubscribe", "doOnSubscribe");
                    }
                })
                .doFinally(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.d(TAG + "doFinally", "doFinally");
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe");
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "收到的数据：  " + integer);
                    }

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });
2022-05-11 14:32:48.947 28024-28024/com.app.empty D/MainActivitydelay: start
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnSubscribe: doOnSubscribe
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivity: onSubscribe
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnEach: doOnEach:  1
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnNext: doOnNext:  1
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivity: 收到的数据：  1
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoAfterNext: doAfterNext:  1
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnEach: doOnEach:  2
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnNext: doOnNext:  2
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivity: 收到的数据：  2
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoAfterNext: doAfterNext:  2
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnEach: doOnEach:  3
2022-05-11 14:32:48.950 28024-28024/com.app.empty D/MainActivitydoOnNext: doOnNext:  3
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivity: 收到的数据：  3
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivitydoAfterNext: doAfterNext:  3
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivitydoOnEach: doOnEach:  null
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivitydoOnError: doOnError
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivitydoOnTerminate: doOnTerminate
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivity: onError
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivitydoFinally: doFinally
2022-05-11 14:32:48.951 28024-28024/com.app.empty D/MainActivitydoAfterTermi: doAfterTerminate

4、onErrorReturn() 操作符

* 可以捕获错误。遇到错误时，发送一个特殊事件，并且正常终止.注意后面的事件不会再发送

Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onError(new Throwable("Throwable"));
                        emitter.onNext(3);
                        emitter.onNext(3);
                    }
                })
                .onErrorReturn(new Function<Throwable, Integer>() {
                    @Override
                    public Integer apply(Throwable throwable) throws Exception {
                        Log.e(TAG, "发生了错误：" + throwable.getMessage());
                        return 111111;
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, String.valueOf(integer));
                    }

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });
2022-05-11 14:35:14.041 28266-28266/com.app.empty D/MainActivitydelay: start
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: 1
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: 2
2022-05-11 14:35:14.042 28266-28266/com.app.empty E/MainActivity: 发生了错误：Throwable
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: 111111
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: onComplete

5.onExceptionResumeNext()/onErrorResumeNext() 操作符

    * 遇到错误时发送一个新的Observable 。并且正常终止.注意原Observable后面的事件不会再发送
     * 如果捕获Exception的话使用onExceptionResumeNext() ，捕获错误的用onErrorResumeNext()

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(11);
                emitter.onNext(22);
                emitter.onError(new NullPointerException("NullPointerException"));
                emitter.onNext(33);
            }
        }).onExceptionResumeNext(new Observable<Integer>() {
            @Override
            protected void subscribeActual(Observer<? super Integer> observer) {
                observer.onNext(44);
                observer.onNext(55);

            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, String.valueOf(integer));
            }

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

            @Override
            public void onComplete() {
                Log.d(TAG, "onComplete");
            }
        });
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: 1
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: 2
2022-05-11 14:35:14.042 28266-28266/com.app.empty E/MainActivity: 发生了错误：Throwable
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: 111111
2022-05-11 14:35:14.042 28266-28266/com.app.empty D/MainActivity: onComplete


6、retry() 操作符

     * 作用是：出现错误时，让被观察者重新发送数据
     * 注：若发送错误，则一直重新发送
     * 
     * 有几个重载方法：
     * retry() ： 出现错误时，让被观察者重新发送数据。若错误一直发生，则一直重新发送
     * 
     * retry(long time)：与retry不同的书，若错误一直发生，被观察者则一直重新发送数据，但这持续重新发送有次数限制
     * 
     * retry(Predicate predicate) ：  出现错误时，根据指定逻辑(可以捕获到发生的错误)决定是否让被观察者重新发送数据
     * 
     * retry(new BiPredicate<Integer, Throwable>)：出现错误时，根据指定逻辑(可以捕获重发的次数和发生的错误)决定是否让被观察者重新发送数据
     * 
     * retry（long time,Predicate predicate） ： 出现错误时，根据指定逻辑(可以捕获到发生的错误)决定是否让被观察者重新发送数据。并且有持续重发的次数限制
 

Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onError(new Throwable("发生错误了"));
                        emitter.onNext(3);
                    }
                })
                .retry(new BiPredicate<Integer, Throwable>() {
                    @Override
                    public boolean test(Integer integer, Throwable throwable) throws Exception {
                        // interger 为重试次数 ，throwable 为捕获到的异常
                        Log.e(TAG + "retry", throwable.getMessage());
                        Log.e(TAG + "integer", "重试次数： " + integer);
                        //return true ： 重新发送请求(若持续遇到错误，就持续重新发送)
                        //return false ：    不重新发送数据 并且调用观察者的onError()方法结束
                        if (integer > 3)
                            return false;
                        return true;
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e(TAG + "retry", String.valueOf(integer));
                    }

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

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "onComplete");
                    }
                });
2022-05-11 14:40:10.445 28810-28810/com.app.empty D/MainActivitydelay: start
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 1
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 2
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 发生错误了
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityinteger: 重试次数： 1
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 1
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 2
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 发生错误了
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityinteger: 重试次数： 2
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 1
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 2
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 发生错误了
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityinteger: 重试次数： 3
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 1
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 2
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityretry: 发生错误了
2022-05-11 14:40:10.446 28810-28810/com.app.empty E/MainActivityinteger: 重试次数： 4
2022-05-11 14:40:10.446 28810-28810/com.app.empty D/MainActivity: onError

7、subscribeOn / ObserverOn 操作符

* subscribeOn : 发送事件的线程
     * observerOn： 接收事件的线程
     * <p>
     * 线程调度器：
     * Schedulers.io(): 代表io操作的线程，通常用于网络，读写文件等io密集型的操作
     * Schedulers.compucation(): 代表CPU计算密集型的操作，例如需要大量计算的操作
     * Schedulers.newThread(): 代表一个常规的新线程
     * AndroidSchedulers。mainThread(): 代表Android的主线程

Observable.create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                        emitter.onNext("事件");
                        Log.d(TAG + "subscribeOn_ObserverOn", "发送事件:" + Thread.currentThread().getName());
                    }
                })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.d(TAG + "subscribeOn_ObserverOn", "接收事件:   " + Thread.currentThread().getName());
                    }
                });

8、repeat() 操作符

* repeat操作符的作用是重复发射 observable的数据序列，可以使无限次也可以是指定次数.不传时为重复无限次

Observable.just(1, 2, 3)
                .repeat(3)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG + "repeat", String.valueOf(integer));
                    }
                });

9、retryUntil() 操作符

* 发送事件遇到错误，指定规则是否重新发送。retry(Predicate predicate)。
     * 
     *  return true ： 不重新发送请求，并且调用观察者的onError()方法结束
     *  return false ： 重新发送数据(若持续遇到错误，就持续重新发送)

Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onError(new Throwable("发生错误了"));
                        emitter.onNext(3);
                    }
                })
                .retryUntil(new BooleanSupplier() {
                    @Override
                    public boolean getAsBoolean() throws Exception {

                         //return true ： 不重新发送请求，并且调用观察者的onError()方法结束
                        // return false ： 重新发送数据(若持续遇到错误，就持续重新发送)
                        return false;
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.e(TAG + "retryUntil", String.valueOf(integer));
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

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

10、 retryWhen() 操作符

* 遇到错误时，将发生的错误传递给一个新的被观察者(Observable)，并决定是否需要重新订阅原始被观察者(Observable) & 发送事件

Observable.create(new ObservableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                        emitter.onNext(1);
                        emitter.onNext(2);
                        emitter.onError(new Throwable("发送了错误"));
                        emitter.onNext(3);
                    }
                })
                //遇到Error时会回调
                .retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {
                        return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(Throwable throwable) throws Exception {

                                //1、若返回的Observable发送的事件 = Error ，则原始的Observable则不重新发送事件。该异常信息可在观察者的onError中获得
                                //return Observable.error(throwable);

                                //2、若返回的Observable发送的事件= Next事件(和next的内容无关)，则原始的Observable重新发送事件(若持续遇到错误，则持续发送)
                                return Observable.just(5); //仅仅是作为一个触发重新订阅原被观察者的通知，什么数据并不重要，只有不是onComplete/onError事件
                            }
                        });

                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

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

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

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


 

又双㕛叕、
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RxJava2学习教程（五）do 操作符
dolphkon的博客
04-23 502
上一篇学习了map 操作符和 flatmap 操作符，今天我们来一起学习do操作符，那么什么是do操作符呢？ 我们知道当观察者与被观察者之间建立订阅的连接之后，观察者可以接受到被观察者发送的数据，那么do 操作符就是在被观察者执行周期的关键节点听添加了回调，当执行到那个阶段的时候这些回调就会触发。 do 操作符的分类 在RxJava中，do 系列操作符包含了很多个，主要如以下: doOnSu...
RxJava原理学习
Android小白
04-30 6551
这是对RxJava设计模式以及源码的介绍
RxJava操作符（四）----功能操作符
zengke的博客
05-21 1819
功能操作符： 辅助被观察者(Observable) 发送事件时实现一些功能性需求，如错误处理，线程调度 1、subscribe() 操作符 /** * ==================subscribe 操作符=========================== * * 连接被观察者和观察者 */ public static void ...
RxJava学习：功能性操作符
qq_40194724的博客
02-25 95
RXjava功能操作符
emmitter.on的用法
最新发布
wangzhen12138的博客
05-20 270
方法用于注册事件监听器，即将指定类型的事件处理函数添加到监听器数组中，待该事件被触发时依次执行。在Node.js中，EventEmitter类是处理事件的核心模块，用于实现事件的触发和处理。时，会触发该事件，并执行注册的监听器函数，输出"Event triggered!在上面的示例中，我们创建了一个新的EventEmitter实例。为Function类型，表示要执行的事件处理函数。为String类型，表示要监听的事件名；方法注册了一个监听器，用于处理名为。例如，以下代码演示了如何使用。
Rxjava(其他)--doOnSubscribe原理
new_abc的专栏
10-26 6857
doOnSubscribe一般用于执行一些初始化操作，我们看其实现原理 demo Observable.just(1).doOnSubscribe(new Action0() { @Override public void call() { System.out.println("<<<<<<subsc
Rxjava 中 onError 时 doOnTerminate 不调用的原因探索
afunyusong的专栏
09-07 3707
Rxjava中doOnTerminate 和 doAfterTerminate 一般情况下的调用时机： * doOnTerminate 是在onCompleted或者onError 调用 之前 调用 * doAfterTerminate 是在onCompleted或者onError 调用 之后 调用 以上的前提是：rxjava 订阅之后工作流是以下两种正常情况： 一个或多个onNex
RXJava源码分析
Allence的博客
09-18 942
流程分析：对于被观察者来说，装饰器模式体现在subscribeActual方法对于观察者来说，装饰器模式体现在onNext方法。
rxjava-api-core:rxjava-api-core
05-27
3. **操作符**：RxJava提供了丰富的操作符，如map、filter、reduce等，用于转换和操作数据流，类似于函数式编程中的高阶函数。 4. **JavaScript的浏览器兼容性**：前端开发者需要关注代码在不同浏览器中的表现，`...
learning-rx-java：使用该书学习Rxjava-使用RxJava进行React式编程
02-12
2. **转换操作**：详细讲解如何使用RxJava操作符对数据流进行转换，例如将一个数据流映射到另一个数据流，或者过滤不满足条件的数据。 3. **组合操作**：介绍如何将多个Observable合并为一个，或者如何交替处理多个...
RxJava-Android开发_Essentials中文翻译版_官方中文版
06-29
最后，《RxJava官方中文文档.pdf》提供了RxJava的官方参考，其中包含了所有操作符的详细说明和使用示例。这对于深入学习和查找特定功能的实现方法非常有用。官方文档通常是最准确和最新的信息来源，对于解决实际开发...
RX操作之辅助操作符二（doonunsubscribe、doOnCompleted、doOnError、doOnTerminate、finallyDo、delay、delaySubscription）
lppl010_的专栏
06-11 783
https://blog.csdn.net/nicolelili1/article/details/52165093 一、doOnUnSubscribe 取消订阅时的监听 Observable<Integer> observable = Observable.just(1,2,3,4,5,6); Subscriber<Integer> subs...
RxJava/RxAndroid : doAfterNext
Zhang Phil
01-19 1484
RxJava/RxAndroid : doAfterNextimport android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import io.reactivex.Observable; import io.reactivex.Observer; import
Rxjava2 源码解析（一）
ls4568206的博客
11-04 231
到目前为止，主流框架Rxjava+Retrofit 已经越来越受到各位开发者的喜爱，虽然之前也用过，但是一直没有弄清里面的原理，导致面试阶段被面试官全程吊打，痛定思痛，下决心好好沉下心来，整理一些知识，与诸君共勉。 好了，闲话少说，下面的一段代码是一段简单的被观察者与观察者的订阅过程： private void test() { Observable<String&gt...
Android主流三方库源码分析（五、深入理解RxJava源码）
weixin_sjk6070的博客
02-19 168
成为一名优秀的Android开发，需要一份完备的知识体系，在这里，让我们一起成长为自己所想的那样~。 到目前为止笔者分析了Android中最热门的网络底层和封装框架：Android主流三方库源码分析（一、深入理解OKHttp源码）和Android主流三方库源码分析（二、深入理解Retrofit源码），Android中使用最广泛的图片加载框架Glide的加载流程：Android主流三方库源码分析（三...
RxJava从入门到不离不弃（五）——Scheduler调度
jiashuai94的博客
10-13 1386
前言完整代码，请查看我的github：https://github.com/shuaijia/LiveLike，喜欢的话就给点个赞喽^_^视频直播想必大家都不谋生，从2015年左右开始，视频直播开始大量普及，市面上的大中型APP基本上都有直播功能，比如专做直播的斗鱼、花椒等。大家都可能看过别人直播甚至参与过直播，那么对精彩的内容总忍不住点赞、送礼物！那作为开发的我们，总是以技术的角度看待世界，看到酷
java observable 使用_Rxjava2 Observable的辅助操作详解及实例（一）
weixin_31318441的博客
02-26 617
简要：需求了解：Rxjava中有一些方便的辅助操作符，来更方便我们的函数式的编程。比如延迟、定时、指定操作的监听、数据类型转换等一系列的操作。下面列出了一些用于Observable的辅助操作符：Delay：延时发射Observable的结果。Do：注册一个动作作为原始Observable生命周期事件的监听器。SubscribeOn：指定Observable自身在哪个调度器上执行。ObserverO...
RxJava2最全面、最详细的讲解（三）
qq_32534441的博客
03-21 489
一、概述 RxJava如此受欢迎，是因为提供了丰富且功能强大的操作符，几乎能完成所有的功能需求。下面我们会继续学习其他操作符。RxJava2在第一篇文章作了详细的介绍，是一个基于事件流的异步操作库。第二篇文章中讲解了RxJava的变换操作符，组合操作符，合并操作符（链接和源码在文章最后给出）；如果不了解Rxjava2可以参考下RxJava2最全面、最详细的讲解(一)，如果英文比较好而且有兴趣的可以...
探索RxJava：从基础到高级操作符详解
此文档详细介绍了RxJava的核心概念、主要操作符和功能，以便开发者能够快速上手并熟练运用。 1. **Introduction**: 开篇介绍RxJava的背景和目的，强调其在非阻塞I/O、事件驱动编程中的优势，以及与Java语言的集成。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

又双㕛叕、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值