我的RxJava 学习之旅 五

最新推荐文章于 2024-08-29 08:16:10 发布
最新推荐文章于 2024-08-29 08:16:10 发布
阅读量170 收藏
点赞数
分类专栏： Android Rxjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/plx_csdn/article/details/79576971
版权

onErrorReturn : 处理Observable中的onError事件(自己消化掉)并返回一个自己设定的数据

public static void test24(){
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onError(new NullPointerException("......"));
                subscriber.onNext(3);
            }
        }).onErrorReturn(new Func1<Throwable, Integer>() {
            @Override
            public Integer call(Throwable throwable) {
                return 10;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.v(TAG, "...call = " + integer);
            }
        });
    }

onErrorResumeNext/onExceptionResumeNext: 当第一个Observable发生错误时 就会调用第二个Observable

public static void test25(){
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onError(new NullPointerException("......"));
                subscriber.onNext(3);
            }
        }).onErrorResumeNext(new Func1<Throwable, Observable<? extends Integer>>() {
            @Override
            public Observable<? extends Integer> call(Throwable throwable) {
                Observable<Integer> integerObservable = Observable.create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        subscriber.onNext(4);
                        subscriber.onNext(5);
                    }
                });
                return integerObservable;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.v(TAG, "...call = " + integer);
            }
        });
    }

retry:如果原始的Observable发生错误,retry是从新订阅关系

public static void test27(){
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onError(new NullPointerException("......"));
                subscriber.onNext(3);
            }
        })
                .retry(3) // 重复订阅三次
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.v(TAG, "...call = " + e.getLocalizedMessage());
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.v(TAG, "...call = " + integer);
                    }
                });
    }

类似的函数还有 :

Javadoc: retry()) ⽆论收到多少次onError通知，都会继续订阅并发射原始Observable。

Javadoc: retry(long)) retry会最多重新订阅指定的次数，如果次数超了，不会尝试再次订阅

Javadoc: retry(Func2)

retryWhen

subscribe/observerOn: 指定被观察者和观察者运行的线程

public static void test28() {
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("test 28");
                Log.v(TAG, "...test = " +Thread.currentThread().getName());
            }
        })
                .subscribeOn(Schedulers.io()) // 指定被观察者线程
                .observeOn(AndroidSchedulers.mainThread()) // 指定观察者线程
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.v(TAG, "...call = " +Thread.currentThread().getName());
                    }
                });
    }

worker

public static void test29(){
        final Scheduler.Worker worker = Schedulers.io().createWorker(); // 创建调度器
        worker.schedule(new Action0() {
            @Override
            public void call() {
                Log.v(TAG, "...call = " +Thread.currentThread().getName());
                worker.unsubscribe(); // 避免内存浪费 回收
            }
        });
    }

delaySubscription: 延迟订阅

public static void test30() {
        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Android");
                subscriber.onNext("java");
                subscriber.onNext("python");
            }
        })
               .delaySubscription(2,TimeUnit.SECONDS)
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.v(TAG, "...call = " + s);
                    }
                });
    }

doOnEach: Observable每发送一个数据就会调用它

public static void test31() {
        Observable.just(1,2,3)
                .doOnEach(new Observer<Integer>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.v(TAG, "...onNext = " + integer);
                    }
                }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.v(TAG, "...call = " + integer);
            }
        });
    }
doOnNext:  和上面的一样 
public static void test32() {
        Observable.just(1,2,3)
                .doOnNext(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.v(TAG, "...doOnNext = " + integer);
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.v(TAG, "...call = " + integer);
                    }
                });
    }

doOnSubscribe: 当被观察者被订阅的时候调用

public static void test33() {
        Observable.just(1,2,3)
                .doOnSubscribe(new Action0() {
                    @Override
                    public void call() {
                        Log.v(TAG, "...doOnSubscribe...... "); //先打印这句
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.v(TAG, "...call = " + integer); // 后打印
                    }
                });
    }

doOnUnSubscribe : 什么时候取消订阅

public static void test34() {
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onCompleted(); // 当调用onCompleted方法时 取消订阅关系
                subscriber.onNext(3);
                subscriber.onCompleted();
            }
        })
                .doOnUnsubscribe(new Action0() { // 当系统取消订阅关系时 调用这个方法
                    @Override
                    public void call() {
                        Log.v(TAG, "...doOnUnsubscribe... ");
                    }
                })
                .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.v(TAG, "...call = " + integer);
            }
        });

    }

log:


如果使用 unSafeSubscribe,那么即使调用了onCompleted方法 也不会解除订阅关系

public static void test34() {
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onCompleted();
                subscriber.onNext(3);
                subscriber.onCompleted();
            }
        })
                .doOnUnsubscribe(new Action0() { // 当系统取消订阅关系时 调用这个方法
                    @Override
                    public void call() {
                        Log.v(TAG, "...doOnUnsubscribe... ");
                    }
                })
                .unsafeSubscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.v(TAG, "...call = " + integer);
                    }
                });

    }

seralize:

public static void test34() {
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onCompleted();
                subscriber.onNext(3);
                subscriber.onCompleted();
            }
        })
                .serialize() // 只要调用了onCOmpleted方法 那么即使没有取消订阅 onCompleted后的数据也不会执行了
                .doOnUnsubscribe(new Action0() { // 当系统取消订阅关系时 调用这个方法
                    @Override
                    public void call() {
                        Log.v(TAG, "...doOnUnsubscribe... ");
                    }
                })
                .unsafeSubscribe(new Subscriber<Integer>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.v(TAG, "...call = " + integer);
                    }
                });

    }

timeOut: 设置发送数据的时间

 public static void test35() {
        Observable
                .interval(2,TimeUnit.SECONDS)
                .timeout(2,TimeUnit.SECONDS)  // 可用于网络请求时候的设置
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.v(TAG, "...call = " + aLong);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.v(TAG, "...call = " + throwable);
                    }
                });
    }

using:

public static void test36() {
       /* using(Func0,Func1,Action1)操作符接受三个参数：
        1. ⼀个⽤于创建⼀次性资源的⼯⼚函数
        2. ⼀个⽤于创建Observable的⼯⼚函数
        3. ⼀个⽤于释放资源的函数*/

        Observable.using(new Func0<String>() {
            @Override
            public String call() {
                return "Hello android";
            }
        }, new Func1<String, Observable<String>>() {
            @Override
            public Observable<String> call(String s) {
                return Observable.just(s);
            }
        }, new Action1<String>() {
            @Override
            public void call(String s) {
                Log.v(TAG, "...清理资源 = " );
                s = null;
            }
        })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                        Log.v(TAG, "...onCompleted = " );
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.v(TAG, "...onNext = " + s);
                    }
                });

    }

buffer: 数据缓存发送

 public static void test37() {
        // buff就是将发送的数据进行缓存 缓存长度由自己设置 达到缓存长度后就进行统一发送
        // 如果被观察者和观察者不在同一线程 可能会发送数据丢失的情况
        Observable<List<String>> buffer = Observable.just("1", "2", "3")
                .buffer(2);
        buffer.subscribe(new Action1<List<String>>() {
            @Override
            public void call(List<String> strings) {
                Log.v(TAG, "...,....................");
                for (int i = 0; i < strings.size(); i++) {
                    Log.v(TAG, "...call.. = " + strings.get(i));
                }
            }
        });


    }

window: 功能和buffer差不多,不同的是将一个Observable拆分成多个Observable

public static void test38() {
    
        Observable<Observable<String>> window = Observable.just("1", "2", "3").window(2);
        window.subscribe(new Action1<Observable<String>>() {
            @Override
            public void call(Observable<String> stringObservable) {
                stringObservable.subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.v(TAG, "...call.. = " + s);
                    }
                });
            }
        });
    }

map:Observable的数据转换 这里转换的只是对象里面的数据值而已 并不能转换对象类型

public static void test39() {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("张三",17));
        students.add(new Student("李四",17));
        students.add(new Student("张6",17));
        Observable.from(students)
                .map(new Func1<Student, Student>() {
                    @Override
                    public Student call(Student student) {
                        if (student.name.equals("李四"))
                        {
                            student.name = "hahah";
                        }
                        return student;
                    }
                }).subscribe(new Action1<Student>() {
            @Override
            public void call(Student student) {
                Log.v(TAG, "...call.. = " + student.name);
            }

        });
    }

flatMap: 转换发送数据对象

public static void test40() {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("张三",17));
        students.add(new Student("李四",17));
        students.add(new Student("张六",17));
        students.add(new Student("张一",12));
        students.add(new Student("张二",11));
        students.add(new Student("张五",10));
        Observable.from(students)
                .flatMap(new Func1<Student, Observable<LittleStudent>>() {
                    @Override
                    public Observable<LittleStudent> call(Student student) {
                        if (student.age < 15)
                        {
                            return Observable.just(new LittleStudent(student.name,student.age));
                        }
                        return null;
                    }
                })
                .subscribe(new Action1<LittleStudent>() {
                    @Override
                    public void call(LittleStudent littleStudent) {
                        Log.v(TAG, "...call.. = " + littleStudent.name);
                    }
                });

    }

这里可以发现 flatMap把发送的数据类型由Student--->LittleStudent 

merge: 合并Observable

 public static void test41() {
        Observable<Integer> ob = Observable.just(1, 3, 5);
        Observable<Integer> observable = Observable.just(2, 4, 6);
        Observable.merge(ob,observable)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.v(TAG, "...call.. = " + integer);
                    }
                });

    }

startWith: 可以在Observable发送之前的准备工作/（如果你想⼀个Observable发射的数据末尾追加⼀个数据序列可以使⽤Concat操作符。

Observable<String> o1 = Observable.just("模拟⽹络请求");
Observable<String> o2 = o1.startWith("⽹络请求之前的准备⼯作");
o2.subscribe(new Action1<String>() {
 @Override
 public void call(String value) {
 Log.i(TAG, value);
 }
});

zip: 两个Observable的压缩,具体算法看Func  假设被观察者o1发送的数据为1 2 ，被观察者o2发送的数据为3，4，5。那么zip压缩发送的数据个数以最低个也就是2个为准。

public static void test42() {
        Observable<Integer> ob = Observable.just(1, 3, 5);
        Observable<Integer> observable = Observable.just(2, 4, 6);
        Observable.zip(ob, observable, new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                return integer - integer2;
            }
        })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.v(TAG, "...call.. = " + integer);
                    }
                });


    }

plx_csdn
关注
专栏目录
我的RxJava学习之旅 四
plx_csdn的博客
03-14 196
distinct 去除重复数据public static void test13() { // 过滤重复的数据 List&lt;Student&gt; list = new ArrayList&lt;&gt;(); list.add(new Student("张三",18)); list.add(new Student("李四",18...
我的RxJava学习之旅 一
plx_csdn的博客
03-12 170
我学习的RxJava是从1.0版本开始的,目前流行的都是2.0,但网上好多的文章都是写2.0版本,对于我这个从未接触的人来说好多地方是看不懂的(某些操作符根本不知道意思),所以只要从最基本的一步一步来,哎 人笨就是这样的---RxJava的原理我就不献丑了--下面开始正文 我只讲操作符Observable&lt;String&gt; observable = Observable.create(n...
我的RxJava学习之旅 二
plx_csdn的博客
03-12 157
AsyncSubject 它可以是被观察者 也可以是观察者 (ps: 雌雄同体)public static void test4(){ // public abstract class Subject&lt;T, R&gt; extends Observable&lt;R&gt; implements Observer&lt;T&gt; 源码 AsyncSubje...
Rxjava之旅-入门篇
坠崖的雏鹰的博客
10-12 489
前言 Rxjava越来越火，现在是Android里面一个重要的框架，想要进阶安卓就想必要去了解一下什么是Rxjava。看了很多关于Rxjava的文章，故此留下学习的印记，让自己或者有需要的人去学习了解接触。然后一步一步去揭开Rxjava神秘的面纱~ Rxjava是什么 引用官方的一句话- “a library for composing asynchronous and event-based pr
Rxjava之旅-初级篇
坠崖的雏鹰的博客
10-13 382
前言 在上篇文章中讲了最基本的Rxjava用法，其实还有很多知识没有讲。这次来补充一下上文中一些内容和继续深入去了解Rxjava。 补充 先来看看两个接口 Action1<String> Action1 = new Action1<String>() { // 可以用来实现onNext() @Override public void call(String s) {
探索RxJava之旅：RxBasicsKata实战挑战
最新发布
gitblog_00841的博客
08-29 550
探索RxJava之旅：RxBasicsKata实战挑战 RxBasicsKataPractical challenges for RxJava learners项目地址:https://gitcode.com/gh_mirrors/rx/RxBasicsKata 在复杂多变的异步编程世界中，RxJava以其强大的响应式编程能力，成为了许多开发者心中的明星库。但对于初学者而言，理论到实践的跨越总是...
java 2.0-1.1_RxJava学习之旅二 2.0.1版本和1.0简单实用的对比讲解
weixin_30616309的博客
02-27 151
第一篇用了1.0版本的RxJava 从现在开始来使用2.0.1，还是使用新的好一些compile 'io.reactivex.rxjava2:rxjava:2.0.1'compile 'io.reactivex.rxjava2:rxandroid:2.0.1'解释一下其中两个陌生的玩意：ObservableEmitter和Disposable.ObservableEmitter： Emitter是...
自定义RxJava之旅
天然居
07-07 2788
序幕 什么是RxJava RxJava的特性 RxJava有什么用 自定义RxJava之旅 同步方式 异步回调方式 异步任务方式-原始 异步任务方式-事件变换 异步任务方式-操作符控制事件变换 异步任务方式-Lambda简写事件变换 异步任务方式-事件链式变换 RxJava方式-原始 RxJava方式-Lambda链式序幕1.什么是RxJava？RxJava是一个针对于Java语言的一个异步的响应式
RxJava2Demo：开启响应式编程之旅
gitblog_00914的博客
08-16 512
RxJava2Demo：开启响应式编程之旅 RxJava2Demo给初学者的RxJava2.0系列教程的demo项目地址:https://gitcode.com/gh_mirrors/rx/RxJava2Demo 项目介绍 RxJava2Demo 是一个专为初学者设计的开源项目，旨在通过一系列的示例代码和教程，帮助开发者快速掌握RxJava 2.0的核心概念和使用方法。RxJava是一个在Jav...
essentials中文 - rxjava 入门书籍推荐
02-05
RxJava 是一个非常重要的 Java 库，它引入了反应式编程的概念，使得异步处理变得更加简单和优雅。在本文中，我们将深入探讨 RxJava 的基础知识，以及如何通过入门...希望以上的介绍能帮助你开启 RxJava 的学习之旅。
我的Android进阶之旅------>RxJava学习资料汇总
字节卷动
04-29 6373
在响应式编程中，应该牢记以下两点：everything is a stream（一切皆流）don't break the chain（不要打断链式结构）记住，可观测序列就像一条河，它们是流动的。你可以“过滤”一条河，你可以“转换”一条河，你可以将两条河合并成一条，然后它依旧是流动的。最后，它将成为你想要的那条河。"Be Water,my friend"  --Bruce Lee(李小龙)-----
【我的Android进阶之旅】Realm数据库学习资料汇总（持续更新）
字节卷动
09-09 2611
介绍realm是一个跨平台移动数据库引擎，支持iOS、OS X（Objective-C和Swift）以及Android。2014年7月发布。由YCombinator孵化的创业团队历时几年打造，是第一个专门针对移动平台设计的数据库。目标是取代SQLite。为了彻底解决性能问题，核心数据引擎C++打造，并不是建立在SQLite之上的ORM。如果对数据引擎实现想深入了解可以查看：Realm 核心数据库引擎
[RxJS学习之旅] 之 初识RxJs
前端小愤青
11-15 1029
函数编程特点 纯函数 声明式 数据不可变性 函数响应式编程优势 数据流抽象了很多现实问题 擅长处理异步操作 把复杂问题分解成简单问题的组合 Ractive Extension 也叫 ReactiveX,或者简称Rx,指的是实践响应式编程的一套工具。Rx是一个大家族它包含 RxJava、RxPy等，RxJS是Rx用JavaScript语言实现。 RxJs擅长处理异步操作,因为它采用推的处...
Java+Opencv 颜色识别
热门推荐
plx_csdn的博客
04-10 1万+
Java+Opencv 颜色识别 最近在做的项目中涉及到了图像识别,使用的第三方检测是Opencv,鉴于网上用Java来做的资料非常少,所以我就写了这篇博客,希望对以后的同学有点帮助! 注意:颜色提取对图片要求较高,如果你的图片比较模糊的(几百kb,有2M就没问题了),请不要浪费时间了,这里写的是关于颜色的提取——- 原图: 这里讲述红色的提取: 1,获取图片对象Mat
Android 判断栈中Activity是否存在
plx_csdn的博客
06-22 9988
网上各种办法，最后经过测试，在栈中你能获取到的只有baseActivity和topActivity，如果你需要判断的Activity在栈别的位置，那么根本判断不了，因为返回的只有栈中Activity的个数，并没有Activity的名字。 private boolean isExistMainActivity(Class<?> activity) { Intent ...
Android app 防止用户短时间内多次点击
plx_csdn的博客
03-27 2973
日常开发中，app必须处理好用户连续点击的问题，因为短时间内的多次重复点击，不管是网络请求或者提交数据，都会重复，网络请求中虽然也可以设置过滤重复的提交，但当你点击一个按钮打开一个Activity，你就会打开多个了，设置Activity的启动模式是没有用处的。如果你还记得android的事件分发机制，你就发现出来很简单了。 1 android事件分发 借用网络上的一张图，可以发现事件分发是有个U型走势，无论什么事件，都是从Activity的dispatchTouchEvent（）分发的，需要注意事件分发的
RecyclerView 根据item宽自适应网格布局
plx_csdn的博客
06-27 2950
在Github里面找了下,有hongyang大佬的flowLayout,但是好久没有维护了,Android8.0貌似也使用有问题,后面就找到了Google官方的 FlexboxLayoutManager,地址是:https://github.com/google/flexbox-layout,使用也非常的简单 FlexboxLayoutManager layoutManager = new...
Compilation error. See log for more details
plx_csdn的博客
06-29 2759
如果xml文件配置错误,build和clean等是找不到错误具体位置的,使用命令:gradlew clean build 可以找到xml文件错误的位置 对于第三方SDK冲突的问题:application标签下面配置: tools:replace="android:allowBackup" android:allowBackup="false" ...
RxJava & RxAndroid 学习笔记
"RxJava和RxAndroid的相关学习资料和链接" RxJava和RxAndroid是用于构建异步和响应式应用程序的库，它们基于 Reactive Extensions (Rx) 的概念。RxJava 是针对 Java VM 的实现，而 RxAndroid 是 RxJava 的扩展，专...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

plx_csdn

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

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

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

打赏作者

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

抵扣说明：

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

余额充值