RxJava学习总结

最新推荐文章于 2024-05-03 07:44:56 发布

青衫白衣98

最新推荐文章于 2024-05-03 07:44:56 发布

阅读量247

点赞数

分类专栏： Android 文章标签： android

本文链接：https://blog.csdn.net/weixin_44630656/article/details/116573971

版权

Android 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

RxJava学习总结

一、RxJava概述
二、RxJava的使用
三、操作符介绍

参考博客：RxJava2最全面、最详细的讲解（一）

一、RxJava概述

在这里插入图片描述

RxJava最核心的两个东西Observable（被观察者、事件源）和Observer（观察者），Observable发出一系列的事件，Observer处理这些事件。在Observer接收到事件处理之前我们很方便地对结果做出各种拦截处理等。

RxJava的流程图大致如下：

添加依赖：

implementation 'io.reactivex.rxjava2:rxjava:2.0.4'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

二、RxJava的使用

2.1 RxJava观察者模式

RxJava有四个基本概念：Observer(观察者)，Observable(被观察者)，subscribe(订阅)，事件。Observer和Observable通过subscribe()实现订阅关系，从而Observable可以在需要的时候发出事件通知Observer。

Observer： 观察者，它决定事件发生时有怎么样的行为；
Observable： 被观察者，它决定什么时候出发事件以及触发什么样的事件；
subscribe： 订阅，将Observer和Observable关联起来。

2.2 RxJava的基本实现

1、创建被观察者Observable

它决定什么时候出发事件以及触发怎么样的事件，通过Observable.create(ObservableOnSubscribe)创建被观察者实例，这是最基本的创造事件序列的方法，并为它定义事件出发规则。

//创建被观察者Observable
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        Log.e(TAG, "subscribe()线程==" + Thread.currentThread().getName());
        e.onNext("RxJava：e.onNext== 第一次");
        e.onNext("RxJava：e.onNext== 第二次");
        e.onNext("RxJava：e.onNext== 第三次");
        e.onComplete();
    }
});

创建一个ObservableOnSubscribe对象并且实现subscribe()方法，设定了事件的内容是String，并返回ObservableEmitter，相当于一个计划表，当Observable被订阅的时候，复写subscribe()方法定义发送的事件，ObservableEmitter是事件发射器，定义并且向观察者发送需要发送的事件，onNext()会被执行三次，最后执行onComplete()方法，这样由被观察者调用观察者回调的方法，实现了被观察者向观察者传递事件。

2、创建观察者Observer

它决定事件触发有怎样的行为，定义响应事件的行为，直接new一个Observer观察者实例，实现其中相应的方法：

//创建观察者Observer
Observer<String> observer = new Observer<String>() {
     @Override
     public void onSubscribe(Disposable d) {
         Log.e(TAG, "onSubscribe == 订阅,"+ Thread.currentThread().getName());
     }

     @Override
     public void onNext(String s) {
         Log.e(TAG, "onNext == " + s+","+Thread.currentThread().getName());
     }

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

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

onSubscribe(Disposable d)： 事件订阅成功回调，返回Disposable请求实例，可以通过d.dispose()取消请求；
onNext(T)： 响应事件的方法，发送事件时，观察者会回调onNext()方法，接收事件数据；
onError()： 事件队列异常，在处理事件出现异常的时候回触发这个方法，其他事件不会再继续发出；
onComplete()： 事件队列完结，当不再有新onNext()发出时，需要触发onComplete()方法来作为标志，其他事件不会再继续发出

注意：在一个正确的事件运行队列中，onError()和onComplete()有且仅有一个出现，还是在事件的最后出现，即onError()和onComplete()是互斥的，当一个出现了，另一个就不再回出现。

3、subscribe()

订阅，连接Observable(被观察者)和Observer(观察者)。

 //订阅(观察者观察被观察者)
 observable.subscribe(observer);

Observable是被观察者，observer是观察者，创建完Observer和Observable之后，通过subscribe()将两者关联起来。

通过该调用，回调观察者的相关方法，从而响应被观察者响应的事件，Observable只生产事件，真正发送事件的是在它订阅的时候，即subscribe()被调用的时候。

执行结果：
在这里插入图片描述

另外：观察者Obaserver的subscribe具有多个重载的方法：

    //观察者不对被观察者发送的事件做出响应(但是被观察者还可以继续发送事件)
    public final Disposable subscribe()
 
    //观察者对被观察者发送的任何事件都做出响应
    public final void subscribe(Observer<? super T> observer)
 
    //表示观察者只对被观察者发送的Next事件做出响应
    public final Disposable subscribe(Consumer<? super T> onNext)
 
    //表示观察者只对被观察者发送的Next & Error事件做出响应
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)
 
    //表示观察者只对被观察者发送的Next & Error & Complete事件做出响应
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
                                      Action onComplete)
 
    //表示观察者只对被观察者发送的Next & Error & Complete & onSubscribe事件做出响应
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
                                      Action onComplete, Consumer<? super Disposable> onSubscribe)

2.3 Scheduler调度者

在RxJava默认规则中，事件的发出和消费都是在同一个线程中发生的，那么上面的例子来说，就是一个同步的观察者模式。观察者模式的本省就是后台处理，前台回调的异步机制，因此异步对RxJava来说是至关重要的，异步的实现则需要用到Scheduler调度器来切换线程。

在RxJava中Scheduler(调度器)相当于线程控制器，RxJava通过Scheduler来指定那一部分代码执行在哪一个线程。我们来看看简单的例子：

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> e) throws Exception {
        Log.e(TAG, "subscribe()线程==" + Thread.currentThread().getName());
        e.onNext("RxJava：e.onNext== 第一次");
        e.onNext("RxJava：e.onNext== 第二次");
        e.onNext("RxJava：e.onNext== 第三次");
        e.onComplete();
    }
}).subscribeOn(Schedulers.io())//指定被观察者subscribe()(发送事件的线程)在IO线程()
        .observeOn(AndroidSchedulers.mainThread());//指定观察者接收响应事件的线程在主线程

log如下：
在这里插入图片描述

执行事件subscribe()方法的线程为IO线程，回调事件方法onNext()的线程为主线程。

由于subscribeOn(Schedulers.io())指定了subscribe()方法发送事件线程在IO线程中执行，observeOn(AndroidSchedulers.mainThread())指定了接收事件在主线程中执行。这种方式非常常见，适用于后台获取数据，前台显示的程序策略。

subscribeOn()：指定Observable被观察者subscribe()时所发生的线程，即指定发生事件的线程
observeOn()：指定Observer观察者接收&响应事件的线程，即订阅者接收事件的线程

注意：多次指定发射事件的线程只有第一次指定有效，也就是说多次调用subscribeOn()只有第一次有效，其余的会被忽略；但是多次指定订阅者接收事件的线程是可以的，也就是说每observeOn()一次，接收事件的线程就会切换一次。

RxJava中内置了很多线程项供我们选择：

Schedulers.io()：代表IO操作的线程，通常用于网络、读写文件等IO密集型的操作。行为模式和new Thread()差不多，只是IO的内部是一个无上限的线程池，可重用空闲的线程，更高效（不要把计算工作放在IO内，可以避免创建不必要的线程）；
AndroidSchedulers.mainThread()：Android的主线程；用于更新UI
Schedulers.newThread()：总是启用新线程，并在新线程中执行操作；多用于耗时操作
Schedulers.computation()：代表CPU计算密集型的操作，即不会被IO等操作限制性能的操作。

三、操作符介绍

3.1 创建操作符

几种常用的创建操作符：

	方法	作用	备注	使用场景
基本创建	create()	创建一个完成的被观察者(Observable)	RxJava中创建被观察者最基本的操作符	1、完整&快速创建被观察者2、数组、集合遍历
快速创建	empty()	快速创建后只发送complete事件，直接通知完成		同上
同上	error()	快速创建后只发送error事件，直接通知异常		同上
同上	never()	快速创建后不发送任何事件		同上
同上	just()	快速创建后直接发送传入的事件	参数最多只能10个，即发送的事件最多10个	同上
同上	fromArray()	快速创建后直接发送传入的数组数据	参数为数组，子类型为任意类型，可10个以上	同上
同上	fromIterable()	快速创建后直接发送传入的集合List数据	参数为集合List，子类型为任意类型，可10个以上	同上
延时创建	defer()	直到观察者Observer订阅被观察者Observable时，才动态创建被观察者&发送事件	通过Observable工厂方法创建被观察者，每次订阅后都会得到一个最新创建的被观察者Observable，确保里面的数据是最新的	1、定时操作2、周期性操作
同上	timer()	快速创建被观察者，指定延时时间，发送一个数值为0的事件	延时指定时间后发送一个参数为0的事件，相当于onNext（0）	同上
同上	interval()	快速创建被观察者，每隔指定时间发送事件	发送事件序列，从0开始，无限递增1	同上
同上	intervalRange()	快速创建被观察者，每隔指定时间发送事件，可指定发送事件数	发送无限递增1的事件序列，可指定起始值大小和事件次数，可延时，类似interval()	同上
同上	range()	快速创建被观察者，连续发送一个时间序列，可指定范围	发送无限递增1的事件序列，可指定起始值大小和事件次数，不可延时，类似intervalRange()	同上
同上	rangeLong()	同上，区别在于数据参数为类型Long	同上	同上

3.1.1 快速创建

1、create()：是所有创建型操作符的“根”，也就是说其他创建型操作符最后都是通过create()来创建的Observable的。

Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            try{
                if (!emitter.isDisposed()){
                    emitter.onNext("RxJava：e.onNext== 第一次");
                    emitter.onNext("RxJava：e.onNext== 第二次");
                    emitter.onNext("RxJava：e.onNext== 第三次");
                    emitter.onComplete();
                }
            }catch (Exception e){
                emitter.onError(e);
            }
        }
    }).subscribe(new Observer<String>() {
        //默认最先复写onSubscribe()
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext == " + s);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete == ");
        }
    });

在使用create()操作符时，最好在被观察者的回调函数subscribe()中加上isDisposed()，以便在观察者断开连接的时候不在执行subscribe()函数中的相关逻辑，避免意想不到的错误出现。

打印数据如下：

2、empty()：快速创建被观察者对象，仅发送onComplete()事件，直接通知完成。

//快速创建被观察者对象，仅发送onComplete()事件，直接通知完成。
Observable.empty()
           .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "empty：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Object o) {
            Log.e(TAG, "empty：onNext ==" + o.toString());
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "empty：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "empty：onComplete == ");
        }
    });

打印log如下：

3、error()：快速创建被观察者对象，仅发送onError()事件，直接通知异常。

    //快速创建被观察者对象，仅发送onError()事件，直接通知异常。
    Observable.error(new Throwable("只回调error"))
            .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "error：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Object o) {
            Log.e(TAG, "error：onNext ==" + o.toString());
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "error：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "error：onComplete == ");
        }
    });

打印log如下：

4、never()：快速创建被观察者对象，不发送任何事件。

    //快速创建被观察者对象，不发送任何事件。
    Observable.never()
              .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "never：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Object o) {
            Log.e(TAG, "never：onNext ==" + o.toString());
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "never：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "never：onComplete == ");
        }
    });

打印log如下：

5、Just(T… items)：快速创建被观察者对象，最多只能发送10个事件。

参数类型：任意类型

Observable.just(1, 2, 3, 4, 5).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "just：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "just：onNext == " + integer);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "just：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "just：onComplete == ");
        }
    });

通过just()创建传入Integer类型的参数构建Observable被观察者，相当于执行了onNext(1)~onNext(5)，通过链式编程订阅观察者。log如下：

6、fromArray(T… items)：快速创建被观察者对象，可发送多个任意子类型的数据。

参数类型：数组，子类型可以为任意类型

    //设置需要传入的数组
    String[] strings = {"商品类","非商品类"};
    //传入数组，被观察者创建后会将数组转换成Observable并且发送里面所以的数据
    Observable.fromArray(strings).subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "fromArray：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(String s) {
            Log.e(TAG, "fromArray：onNext == " + s);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "fromArray：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "fromArray：onComplete == ");
        }
    });

通过fromArray()创建被观察者对象，传入数组，被观察者创建后会将数组转换成Observable(被观察者)并且发送里面所有的数据。打印数据如下：

7、fromIterable(Iterable<? extends T> source*)*：快速创建被观察者对象，可发送多个任意子类型的数据。

参数类型：集合，子类型可以为任意类型

    //创建集合
    List<Goods> list = new ArrayList();
                for (int i = 0; i < 3; i++) {
        Goods g = new Goods("名称" + i);
        list.add(g);
    }
    //传入集合，被观察者创建后会将数组转换成Observable并且发送里面所有的数据
                Observable.fromIterable(list).subscribe(new Observer<Goods>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "fromArray：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Goods goods) {
            Log.e(TAG, "fromArray：onNext == " + goods.getName());
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "fromArray：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "fromArray：onComplete == ");
        }
    });

通过 fromIterable() 创建被观察者Observable对象，传入集合，被观察者创建后会将数组转换成Observable(被观察者)并且发送里面所有的数据。打印数据如下：

3.1.2 延迟创建

1、defer()：直到有Observer观察者订阅时，才会通过Observeable的工厂方法动态创建Observeable，并且发送事件

每次订阅后都会得到一个刚创建的最新的Observable对象，确保被观察者对象的数据是最新的。

   //1.初始化i
    Integer i = 100;
    //2.通过defer()定义被观察者（此时被观察者对象还没创建）
    Observable<Integer> defer = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
        @Override
        public ObservableSource<? extends Integer> call() throws Exception {
            return Observable.just(i);
        }
    });
 
    //3.重新设置i值
    i = 200;
 
    //4.订阅观察者（此时才会调用defer,创建被观察者对象）
        defer.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "defer：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Integer i) {
            Log.e(TAG, "defer：onNext == " + i);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "defer：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "defer：onComplete == ");
        }
    });

在订阅的时候才开始创建被观察者对象，然后再发送事件，所以i的值是最新的数据 i = 200；打印log如下：

2、timer()：快速创建Observable被观察者对象，延迟指定时间后发送一个类型为Long的事件

构造方法：

 timer(long delay, TimeUnit unit)
 timer(long delay, TimeUnit unit, Scheduler scheduler)

delay： 延时的时间，类型为Long；
unit： 表示时间单位，有TimeUnit.SECONDS等多种类型；
scheduler： 表示调度器，用于指定线程。

发送的事件类型为Long，数值为0，相当于onNext(0);

final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
    Log.e(TAG, "timer：当前时间 ==" + dateFormat.format(System.currentTimeMillis()));
    //延时3秒后，发送一个long值为0的事件
    Observable.timer(3, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "timer：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "timer：onNext ==" + aLong + "   时间 ==" + dateFormat.format(System.currentTimeMillis()));
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "timer：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "timer：onComplete == ");
        }
    });

延时3秒后，发送一个long值为0的事件，约3秒后响应事件onNext()接收到数据，另外，timer默认运行在一个新的线程上，也可以自定义线程调度器scheduler。打印log如下：

3、interval()：快速创建Observable被观察者对象，每隔指定的时间就发送相应的事件，事件序列从0开始，无限递增1；

构造方法：

//在指定延迟时间后，每个多少时间发送一次事件
interval(long initialDelay, long period, TimeUnit unit)
 
//在指定的延迟时间后，每隔多少时间发送一次事件，可以指定调度器
interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
 
//每间隔多少时间发送一次事件，使用默认的线程
Observable<Long> interval(long period, TimeUnit unit)
 
//每间隔多少时间发送一次事件，可以指定调度器
interval(long period, TimeUnit unit, Scheduler scheduler)

initialDelay： 表示延迟开始的时间，类型为Long；
period： 距离下一次发送事件的时间间隔，类型为Long；
unit： 时间单位，有TimeUnit.SECONDS等多种类型；
scheduler： 表示调度器，用于指定线程。

interval()提供了多种构造方法选择，每隔一定的时间period就发送一次事件，事件数据从0开始，无限增加1。

//initialDelay：表示延迟开始的时间, period：距离下一次发送事件的时间间隔, unit：时间单位    
 Observable.interval(3, 1, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "interval：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "interval：onNext ==" + aLong);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "interval：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "interval：onComplete == ");
        }
    });

上述列子延迟3秒后开始发送事件，每次发送事件的时间间隔为1秒，无限发送，时间单位设置为秒，这种情景我们可以用来设置定时器等相关操作，打印log如下：

4、intervalRange()：类似于interval()，快速创建一个被观察者对象，指定时间间隔就发送事件，可以执行发送事件的数量，数据依次递增1。

构造方法：

intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
 
intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

start： 表示事件开始的数值大小，类型为Long；
count： 表示事件执行的次数，类型为long，不能为负数;
initialDelay： 表示延迟开始的时间，类型为Long；
period： 距离下一次发送事件的时间间隔，类型为Long；
unit： 时间单位，有TimeUnit.SECONDS等多种类型；
scheduler： 表示调度器，用于指定线程。

注意：count不能为负数，否则会抛出异常，我将count设置为-1，运行报错如下：

//事件开始大小为10，发送5次事件，延迟3秒后执行，每次执行的间隔为1，单位为秒
Observable.intervalRange(10, 5, 3, 1, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "intervalRange：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "intervalRange：onNext ==" + aLong);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "intervalRange：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "intervalRange：onComplete == ");
        }
    });

这里指定了事件开始大小为10，发送5次事件，延迟3秒后执行，每次执行的间隔为1，单位为秒，打印log如下：

5、range(final int start, final int count)：类似于intervalRange()，快速创建一个被观察者对象，指定事件起始值，执行发送事件的数量，但是区别在于range()不能延迟发送的时间。

注意：上述参数的类型是int类型，rangeLong(long start, long count)只是参数类型不同，用法一致。

//start：事件的开始值大小，count：发送的事件次数
Observable.range(5, 4).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "range：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "range：onNext ==" + integer);
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "range：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "range：onComplete == ");
        }
    });

这里指定了事件的开始值大小为5，发送的事件数为4次，一次递增1；打印log如下：

3.2 转换操作符

几种常用的转换操作符：

方法	作用
map()	对Observable发送的每一个事件进行转换
flatMap()	对Observable发送的整个个事件进行转换（无序）
concatMap()	对Observable发送的整个个事件进行转换（有序）
buffer()	从Observable的事件中获取事件放到缓存区再发送事件

变换操作符的主要是对事件序列中的事件进行处理变换，使其转变成不同的事件，再加以处理。这里列举几种常用的操作符

1.Map()

map操作符把被观察者Observable产生的结果通过映射规则转换成另一种结果集，并交给订阅者处理。简单来说就是对被观察者发送的每个事件都通过指定函数的处理，从而转变成另一种事件。

//链式编程
Observable.just(1, 2, 3, 4, 5)
           //使用Map操作符中的Function函数对被观察者发送的事件统一作出处理
           .map(new Function<Integer, Integer>() {
        @Override
        public Integer apply(Integer integer) throws Exception {
            //对被观察者just发送的结果，都全部乘以10处理
            return integer * 10;
        }
    }).subscribe(new Consumer<Integer>() {//订阅
        @Override
        public void accept(Integer integer) throws Exception {//接受事件结果，是处理后的结果
            Log.e(TAG, "map：accept == " + integer);
        }
    });

上面的例子中我们使用just()操作符连续发送1,2,3,4,5等5个事件，通过Map操作符中的Function函数对被观察者发送的事件统一作出乘以10处理，订阅后输出最终结果：

2.flatMap()

flatMap()通过传入一个函数作为参数转换源Observable(被观察者)，在这个函数中你可以自定义转换规则，最后在这个函数中返回一个新的Observable，然后flatMap函数回调方法通过合并这些Observable成一个新的Observable，发送给Observer(观察者)。

即：flatMap拿到一个Observable并返回一个新的Observable

 Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) {
            e.onNext("A");
            e.onNext("B");
            e.onComplete();
        }
    }).flatMap(new Function<String, ObservableSource<String>>() {
        @Override//通过flatMap将被观察者生产的事件进行拆分，再将新的事件转换成一个新的Observable发送
        public ObservableSource<String> apply(String s) {
            List<String> list = new ArrayList<>();
            Log.e(TAG, "flatMap：apply == 事件" + s);
            //将一个事件拆分成两个子事件，例如将A事件拆分成A0,A1两个事件，然后再整个合成一个Observable通过fromIterable发送给订阅者
            for (int j = 0; j < 2; j++) {
                list.add("拆分后的子事件" + s + j);
            }
            return Observable.fromIterable(list);
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            Log.e(TAG, "flatMap：accept == " + s);
        }
    });

上面我们发送了A、B两个事件，在flatMap中接收到A事件后，将A事件拆分成A0，A1两个事件，再通过fromIterable(list)整合成一个Observable发送给订阅者。打印log如下：

注意：flatMap在合并Observable结果时，可能存在交叉的情况出现，即新合并生成的序列可能是无序的。

3.concatMap()

concatMap() 和 flatMap() 基本上是一样的，只不过 concatMap() 转发出来的事件是有序的，而 flatMap() 是无序的

Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) {
            e.onNext("A");
            e.onNext("B");
            e.onComplete();
        }
    }).concatMap(new Function<String, ObservableSource<String>>() {
        @Override//通过concatMap（有序）将被观察者生产的事件进行拆分，再将新的事件转换成一个新的Observable发送
        public ObservableSource<String> apply(String s) {
            List<String> strings = new ArrayList<>();
            Log.e(TAG, "concatMap：apply == 事件" + s);
            for (int j = 0; j < 2; j++) {
                strings.add("拆分后的子事件" + s + j);
            }
            return Observable.fromIterable(strings);
        }
    }).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            Log.e(TAG, "concatMap：accept == " + s);
        }
    });

打印的log如下：

4.buffer()

buffer()操作符将Observable(被观察者)需要发送的事件周期性收集到列表中，并把这列表提交给Observer(观察者)，观察者处理后，清空buffer列表，同时接收下一次的结果交给订阅者，周而复始。

需要注意的是：一但初始的Observable在产生事件中出现异常，即使buffer()收集到已经存在的结果，订阅者也会马上收到这个异常，并结束整个过程。

 Observable.just("A", "B", "C", "D", "E")//这里演示发送5个事件
         .buffer(3, 2)//缓存列表数量为3个，步长为2
                .subscribe(new Observer<List<String>>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "buffer：onSubscribe == 订阅");
        }
 
        @Override
        public void onNext(List<String> strings) {
            Log.e(TAG, "buffer：onNext == 缓存事件数：" + strings.size());
            for (int j = 0; j < strings.size(); j++) {
                Log.e(TAG, "buffer：子事件==" + strings.get(j));
            }
        }
 
        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "buffer：onError == " + e.getMessage());
        }
 
        @Override
        public void onComplete() {
            Log.e(TAG, "buffer：onComplete == ");
        }
    });

上述例子设置了"ABCDE"5个事件，缓存事件数为3个，步长为2。在被观察者的事件中，第一次获取3个事件数放到缓存区域，即"A"，“B”，“C”，发送给订阅者；第二次获取时，因为步长=2，所以事件往后移动2个，即指针往后移动2位，从"C"开始取三个事件，即"C"，“D”，“E"发送给订阅者；第三次获取时，事件再在第二次的基础上往后移动2个，即到了"E”，取3个事件，事件不足3个，只能够取"E"发送给订阅者。看图比较好理解，我们来看看buffer()的原理图：

打印结果如下：

3.3 其他操作符

RxJava转换、组合、合并等操作符的使用
 详细介绍了RxJava的使用
 RxJava过滤、其他操作符的使用

青衫白衣98

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
RxJava学习总结

这里写目录标题一级目录一级目录依赖 implementation 'io.reactivex.rxjava3:rxandroid:3.0.0' implementation 'io.reactivex.rxjava3:rxjava:3.0.0'
复制链接

扫一扫