RxJava基础练习（2）

最新推荐文章于 2021-06-03 07:13:25 发布
最新推荐文章于 2021-06-03 07:13:25 发布
阅读量329 收藏
点赞数
分类专栏： Android总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29502523/article/details/51701274
版权

//—————————————4: Action0和Action1 讲解————————————————————–
/**
* 肯定有同学对Action0和Action1很困惑,就像当初我刚看到那样子;
* 那就听听扔物线给大家讲一下:
*
* MaLin:扔物线大哥,你能够给我们讲解一下Action0和Action1是什么,以及他们之间的区别吗?
*
* 扔物线:大家好,我简单的解释一下:
* Action0 是 RxJava 的一个接口，它只有一个方法 call()，这个方法是无参无返回值的；
* 由于 onCompleted() 方法也是无参无返回值的，因此 Action0 可以被当成一个包装对象，
* 将 onCompleted() 的内容打包起来将自己作为一个参数传入 subscribe() 以实现不完整定义的回调。
* 这样其实也可以看做将 onCompleted() 方法作为参数传进了 subscribe()，相当于其他某些语言中的『闭包』。
*
* Action1 也是一个接口，它同样只有一个方法 call(T param)，这个方法也无返回值，但有一个参数；
* 与 Action0 同理，由于 onNext(T obj) 和 onError(Throwable error) 也是单参数无返回值的，
* 因此 Action1 可以将 onNext(obj) 和 onError(error) 打包起来传入 subscribe() 以实现不完整定义的回调。
* 事实上，虽然 Action0 和 Action1 在 API 中使用最广泛，但 RxJava 是提供了多个 ActionX 形式的接口 (例如 Action2, Action3) 的，
* 它们可以被用以包装不同的无返回值的方法。
*/

//---------------------------------------5: 休息一下!推荐两个好用的日志查看工具-------------------------------------------------------------

//1.[logger](https://github.com/orhanobut/logger) | 一个简洁,优雅,功能强大的Android日志输出工具
//2.[pidcat](https://github.com/JakeWharton/pidcat)|JakeWharton项目一个简洁,优雅的,彩色日志终端查看库|在终端过滤日志信息

/**
 * 使用com.github.orhanobut:logger 库可以查看当前的线程
 *  ╔════════════════════════════════════════════════════════════════════════════════════════
 D  ║ Thread: main
 D  ╟────────────────────────────────────────────────────────────────────────────────────────
 D  ║ MainActivity$11.onNext  (MainActivity.java:338)
 D  ║    MainActivity$11.onNext  (MainActivity.java:354)
 D  ╟────────────────────────────────────────────────────────────────────────────────────────
 D  ║ 观察者 onNext()
 D  ╚════════════════════════════════════════════════════════════════════════════════════════
 D  ╔════════════════════════════════════════════════════════════════════════════════════════
 D  ║ Thread: main
 D  ╟────────────────────────────────────────────────────────────────────────────────────────
 D  ║ SafeSubscriber.onCompleted  (SafeSubscriber.java:83)
 D  ║    MainActivity$11.onCompleted  (MainActivity.java:341)
 D  ╟────────────────────────────────────────────────────────────────────────────────────────
 D  ║ 观察者 onCompleted()
 D  ╚════════════════════════════════════════════════════════════════════════════════════════
 */

//---------------------------------------6 线程控制-Scheduler-------------------------------------------------------------

/**
 * 显示图片
 * 后台线程取数据，主线程显示
 * 加载图片将会发生在 IO 线程，而设置图片则被设定在了主线程。这就意味着，即使加载图片耗费了几十甚至几百毫秒的时间，也不会造成丝毫界面的卡顿。
 */
private void method6() {

    final int drawableRes = R.mipmap.malin;
    Observable.create(new Observable.OnSubscribe<Drawable>() { //1:被观察者
        @Override
        public void call(Subscriber<? super Drawable> subscriber) {
            Logger.d("被观察者");
            Drawable drawable = getResources().getDrawable(drawableRes);
            subscriber.onNext(drawable);
            subscriber.onCompleted();
        }
    })
            .subscribeOn(Schedulers.io())//事件产生的线程。指定 subscribe() 发生在 IO 线程
            // doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。这里将执行在主线程中
            .doOnSubscribe(new Action0() {
                @Override
                public void call() {
                    if (mProgressBar != null) {
                        mProgressBar.setVisibility(View.VISIBLE);//显示一个等待的ProgressBar--需要在主线程中执行
                    }
                }
            })
            .observeOn(AndroidSchedulers.mainThread())//指定 Subscriber 所运行在的线程。或者叫做事件消费的线程
            .subscribe(new Subscriber<Drawable>() {   //3:订阅 //2:观察者
                @Override
                public void onCompleted() {
                    if (mProgressBar!=null){
                        mProgressBar.setVisibility(View.GONE);
                    }
                    Logger.d("观察者 onCompleted()");
                    Toast.makeText(MainActivity.this, "观察者 onCompleted()", Toast.LENGTH_SHORT).show();
                }

                @Override
                public void onError(Throwable e) {
                    if (mProgressBar!=null){
                        mProgressBar.setVisibility(View.GONE);
                    }
                    Logger.d("观察者 onError()");
                    Toast.makeText(MainActivity.this, "观察者 onError() " + e.getMessage(), Toast.LENGTH_SHORT).show();

                }

                @Override
                public void onNext(Drawable drawable) {
                    Toast.makeText(MainActivity.this, "观察者 onNext()", Toast.LENGTH_SHORT).show();
                    Logger.d("观察者 onNext()");
                    mImageView.setImageDrawable(drawable);
                }
            });

}

//—————————————7: 变换 map()————————————————————-
private void method7() {
final int drawableRes = R.mipmap.malin;

    //1:被观察者
    Observable.just(drawableRes)//输入类型 int
            .map(new Func1<Integer, Drawable>() {

                @Override
                public Drawable call(Integer integer) {// 参数类型 String
                    Logger.d("integer:" + integer);
                    return getResources().getDrawable(integer);
                }
            })
            .subscribeOn(Schedulers.io())//事件产生的线程。指定 subscribe() 发生在 IO 线程
            //doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。这里将执行在主线程中
            .doOnSubscribe(new Action0() {
                @Override
                public void call() {
                    if (mProgressBar != null) {
                        mProgressBar.setVisibility(View.VISIBLE);//显示一个等待的ProgressBar--需要在主线程中执行
                    }
                }
            })
            .observeOn(AndroidSchedulers.mainThread())//指定 Subscriber 所运行在的线程。或者叫做事件消费的线程
            .subscribe(new Subscriber<Drawable>() {  //3:订阅 //2:观察者
                @Override
                public void onCompleted() {
                    if (mProgressBar != null) {
                        mProgressBar.setVisibility(View.GONE);
                    }
                    Logger.d("观察者:onCompleted()");
                }

                @Override
                public void onError(Throwable e) {
                    if (mProgressBar != null) {
                        mProgressBar.setVisibility(View.GONE);
                    }
                    Toast.makeText(MainActivity.this, "" + e.getMessage(), Toast.LENGTH_SHORT).show();
                    Logger.d("观察者:onError(Throwable e):" + e.getMessage());
                }

                @Override
                public void onNext(Drawable drawable) {
                    mImageView.setImageDrawable(drawable);
                    Logger.d("观察者:onNext(Drawable drawable):" + drawable.toString());
                }
            });
}

//---------------------------------------8: 练习 中途休息一下-------------------------------------------------------------

//演示嵌套循环
private void method8() {
    ArrayList<Student> students = DataFactory.getData();
    int size = students.size();
    for (int i = 0; i < size; i++) {
        Logger.d("姓名:" + students.get(i).name);
        int sizeCourses = students.get(i).courses.size();
        for (int j = 0; j < sizeCourses; j++) {
            Logger.d("课程:" + students.get(i).courses.get(j).name);
        }
    }
}


/**
 * 需要:依次输入学生的姓名:将每个学生(实体对象)依次发射出去
 * RxJava解决方案:
 * {@link #method8()}
 */
private void method9() {
    //just(T...): 将传入的参数依次发送出来,实现遍历的目的
    Observable.from(DataFactory.getData())
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<Student>() {
                @Override
                public void call(Student student) {
                    Logger.d("观察者:" + student.name);
                }
            });
}


/**
 * 需要:输出学生的姓名:将每个学生的(姓名)依次发射出去
 * RxJava解决方案
 * {@link #method9()}
 */
private void method10() {

    //1:被观察者

    //2:数据转换

    //3:事件产生的线程。

    //4:事件消费的线程。

    //5:被观察者被观察者订阅

    //6:观察者

    Observable.from(DataFactory.getData())

            .map(new Func1<Student, String>() {
                @Override
                public String call(Student student) {
                    return student.name;
                }
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    Logger.d("观察者:onCompleted()");
                }

                @Override
                public void onError(Throwable e) {
                    Logger.d("观察者:onError(Throwable e)  " + e.getMessage());
                }

                @Override
                public void onNext(String s) {
                    Logger.d("观察者:onNext(String s) " + s);
                }
            });

}

/**
 * 需要:输出学生的姓名:将每个学生的(姓名)依次发射出去,对method9()的简化
 * RxJava解决方案
 * 输出学生的姓名
 * {@link #method10()}
 */
private void method11() {
    Observable.from(DataFactory.getData())
            .map(new Func1<Student, String>() {
                @Override
                public String call(Student student) {
                    return student.name;
                }
            })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<String>() {
                @Override
                public void call(String s) {
                    Logger.d("观察者:" + s);
                }
            });

}

//---------------------------------------9: 引入flatmap()-------------------------------------------------------------

/**
 * 需要:输出每一个学生所有选修的课程
 * 嵌套循环的RxJava解决方案
 * 输出每一个学生选修的课程
 * {@link #method11()}
 */
private void method12() {

    //1:被观察者

    //2:被观察者被观察者订阅

    //3:观察者

    Observable.from(DataFactory.getData())
            .subscribe(new Subscriber<Student>() {
                @Override
                public void onCompleted() {
                    Logger.d("观察者:onCompleted()");
                }

                @Override
                public void onError(Throwable e) {
                    Logger.d("观察者:onError(Throwable e)" + e.getMessage());
                }

                @Override
                public void onNext(Student student) {
                    ArrayList<Course> courses = student.courses;
                    for (Course course : courses) {
                        Logger.d("观察者:" + course.name);
                    }
                }
            });

}

/**
 * 需要:输出每一个学生选修的课程,对method12的简化
 * 嵌套循环的RxJava解决方案
 * {@link #method12()}
 * Student->ArrayList<Course>
 */
private void method13() {

    Observable.from(DataFactory.getData())

            .map(new Func1<Student, ArrayList<Course>>() {
                @Override
                public ArrayList<Course> call(Student student) {
                    return student.courses;
                }
            }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<ArrayList<Course>>() {
                @Override
                public void call(ArrayList<Course> courses) {
                    for (int i = 0; i < courses.size(); i++) {
                        Logger.d("观察者:" + courses.get(i).name);
                    }
                }
            });
}

//---------------------------------------10: flatMap()的使用-------------------------------------------------------------

/**
 * 需要:输出每一个学生选修的课程,对method13的简化
 * 嵌套循环的RxJava解决方案
 * {@link #method13()}
 * Student -> ArrayList<Course> -> Observable<Course> ->
 */
private void method14() {

    //1:被观察者

    //2:数据转换

    //3:事件产生的线程。

    //4:事件消费的线程。

    //5:被观察者被观察者订阅

    //6:观察者

    // Student->Course
    Observable.from(DataFactory.getData())
            .flatMap(new Func1<Student, Observable<Course>>() {
                @Override
                public Observable<Course> call(Student student) {
                    return Observable.from(student.courses);
                }
            }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<Course>() {
                @Override
                public void call(Course course) {
                    Logger.d("观察者:" + course.name);
                }
            });
}


//---------------------------------------10: RxBinding的引入-------------------------------------------------------------


/**
 * 需要防止快速连续点击,短时间内连续点击.
 */
private void method15() {


    mImageView.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (ClickUtils.isFastDoubleClick()) {
                        ToastUtil.getInstance().showToast(MainActivity.this, "点击过快啦");
                        return;
                    }
                    ToastUtil.getInstance().showToast(MainActivity.this, "匿名内部类实现click");
                }
            });
        }
    });


}
Android界的小蚂蚁
关注
专栏目录
RxJava代码练习_creating操作符
05-10
代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习代码练习
RxJava基础练习（1）
Android小王子唐涛的空间
06-17 536
//概念解释 //1:被观察者,事件源:它决定什么时候触发事件以及触发怎样的事件 //2:观察者:它决定事件触发的时候将有怎样的行为 //3:订阅 private void method0() { //1:被观察者,事件源 //概念解释:RxJava 使用 Observable.create() 方法来创建一个 Observable ，并为它定义
RxJava语法练习
無名小子的杂货铺
11-26 474
很早之前就听Rxjava 多么神奇，各种评论都有，说学习坡度高，难等等，于是亲自上手试试，说实话刚开始看到这些用法立马就蒙比了，和我们之前的方式不太一样，理解起来还是挺别扭的，之后找了一篇给 Android 开发者的 RxJava 详解 扔物线的，好好研究上几天，认真理解每个例子并自己动手敲出来，也就慢慢能体会到 rxjava 的好用之处了。刚开始学习的时候，为了加深理解，按照这篇 NotRxJav
RxJava基础练习（3）
Android小王子唐涛的空间
06-17 610
/** * RxBinding * RxBinding 是 Jake Wharton 的一个开源库，它提供了一套在 Android 平台上的基于 RxJava 的 Binding API。 * 所谓 Binding，就是类似设置 OnClickListener 、设置 TextWatcher 这样的注册绑定对象的 API。 * 举个设置点击监听的例子。使用 RxBinding ，可以把事件监
RxJavaDemo:本教程基于 RxJava2 实践练习 Demo
05-16
RxJavaDemo RxJava+Retrofit2 的常见实际使用场景 本项目是模仿 在模仿了几个RxJava+Retrofit2的项目之后,可能缺少没有系统学习,总感觉还不能掌握 RxJava+Retrofit2 等开源库的精髓,结合了在网上个人认为较为优秀的文章，码了这库。 项目截图 App体验链接: 推荐项目 项目不在多,在于你自己对知识点的领悟 推荐-推荐的不仅仅是技术 UpateDemo（更新模块）： simplebam/GlideDemo Android 项目从零到上线的全过程 - Android - 掘金 Android 能让你少走弯路的干货整理 - 简书 tvvocold/How-To-Ask-Questions-The-Smart-Way: How To Ask Questions The Smart Way 《提问的智慧》中文版 或许是介绍Android S
RxJava代码练习1
11-30
这个"RxJava代码练习1"很可能是针对初学者设计的一系列实践教程，旨在帮助学习者掌握RxJava的基础概念和用法。 首先，让我们了解RxJava的基本概念。RxJava的核心是Observable（可观察者）和Observer（观察者）。...
Android-rxjavaretrofit练习的demo获取手机号码归属地
08-13
这个"Android-rxjavaretrofit练习的demo获取手机号码归属地"项目是一个很好的实战案例，让我们来深入探讨这两个库以及如何利用它们实现特定功能。 RxJava是一个响应式编程库，它引入了一种新的方式来处理事件和数据...
老罗RxJava视频+源码百度云下载
03-08
通过系统地学习这些材料，不仅可以掌握RxJava的基本用法，还能深入了解其背后的原理，为进一步的技术探索打下坚实的基础。同时，也建议学习者结合实际项目进行练习，以加深理解和提高实际操作能力。
hello-rxjava:作为 RxJava 库的简单“hello world”类型演示的基本 Lipsum 生成器
07-14
《RxJava库的基础应用：构建一个简单的"Lipsum"生成器》 RxJava是一个用于处理异步数据流的Java库，它将函数式编程的概念引入到事件处理中，极大地简化了复杂的多线程和回调处理。这个项目"hello-rxjava"就是针对...
TestApp:Android基础开发工具，提供一些便捷方法，并利用RxJava和Retrofit封装了网络请求组件
05-06
TestApp 测试练习及功能演示项目，baseDevKit module 提供部分便捷工具类及便捷方法，封装了基础网络请求功能（利用RxJava和Retrofit搭建），支持与Activity 和Fragment生命周期绑定，并附有测试用例
android rxjava面试题,android面试（RxJava）
weixin_34711121的博客
06-03 839
RxJava：一个在JVM上使用可观测的序列来组成异步的，基于事件的程序的库。说白了就是异步优势：使用：先明白三个概念：Observable被观察者，Observer观察者，Subscribe订阅 上游Observable和下游observer通过subscribe建立连接，总共就3步：创建上游，创建下游，建立连接。 可以有个很简便的链式写法： subscribe()有很多重载的方法，以下为1...
Rxjava、Reactor学习练习目录
进击的小白
11-17 228
Rxjava学习：onNext、onComplete、doOnNext、doFinally、doAfterTerminate执行顺序
RxJava练习(3)--跳过与截取
liken的专栏
12-31 1739
本例主要讲skip和take的使用
RxJava练习(2)--时间间隔输出字符串
liken的专栏
12-30 4410
RxJava
RxJava练习(1)--timer代替Handler
liken的专栏
12-23 1万+
RxJava Observable
面试神器第二弹：Rxjava熟悉——操作符
风花散却隽世间，雪月寥落化雨田
02-28 4163
上期简单讲了Rxjava的入门，方便大家认识Rxjava，这期带大家了解Rxjava，认识Rxjava的更多特性 Rxjava操作符 Rxjava操作符就是各种方法，每种方法能够帮助我们处理一种情况，Rxjava的强大也就在于这些方法的使用。下面大家认识一下几个比较常用的操作符（方法） Observable.create: 这是最简单操作符，用于创建一个Observ...
Carson带你学Android：手把手带你入门神秘的Rxjava
热门推荐
Carson带你学Android
10-09 3万+
前言 Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。本文主要：面向 刚接触Rxjava的初学者 提供了一份 清晰、简洁、易懂的Rxjava入门教程 涵盖 基本介绍、原理 & 具体使用等解决的是初学者不理解Rxjava原理 & 不懂得如何使用的问题 希望你们会喜欢。 本文主要基于Rxjava 2.0 如果读者还没学习过Rx
【Android】RxJava的使用（二）Action
linder_qzy的专栏
08-02 357
回顾 在上一节Android RxJava的使用（一）基本用法中，介绍了RxJava的基本用法。下面来回顾下实现一次RxJava的基本使用。 例：分别打印"Hellow"、" Wrod" Observable.just("Hello", "World") .subscribe(new Subscriber() {
Rxjava基本介绍
qq_38859786的博客
03-20 3694
一,作用 RxJava的目的就是异步。RxJava的特点就是可以非常简便的实现异步调用，可以在逻辑复杂的代码逻辑中以比较轻易的方式实现异步调用。随着逻辑的复杂，需求的更改，代码可依然能保持极强的阅读性.二,添加依赖io.reactivex.rxjava2:rxjava:2.0.4 io.reactivex.rxjava2:rxjava:2.0.4 ...
RxJava2异常处理深度解析
"RxJava2异常处理详解" 在 RxJava2 中，异常处理是至关重要的，因为如果不正确地处理，异常可能会导致程序崩溃。本文将深入探讨 RxJava2 中的异常情况及其处理方法。 首先，我们需要了解 RxJava2 的订阅方式。最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值