RxJava 四：RxJava 3 操作符（Operators）

最新推荐文章于 2024-04-25 10:00:09 发布

清居雅士

最新推荐文章于 2024-04-25 10:00:09 发布

阅读量737

点赞数 1

分类专栏： RxJava

本文链接：https://blog.csdn.net/qingjuyashi/article/details/106220526

版权

本文详细介绍了RxJava 3中的核心操作符，包括创建、变换、过滤、合并、异常处理、辅助操作符等，通过实例展示了如何使用这些操作符处理数据流，如`create`、`map`、`filter`、`merge`、`subscribeOn`、`observeOn`等，以及它们在实际应用中的作用和用法。

摘要由CSDN通过智能技术生成

分类：

常用：

1．create（创建）：Obserable

2．map（变换）：Data（数据）

3．filter（过滤）：Data（数据）

4．merge（组合）：Observable

操作符（Operators）的实质是函数式编程中的高阶函数，是对响应式编程的各个过程拆分封装后的产物。目的在于灵活操作数。

分类：

1．create（创建操作符）：创建Observable并发送数据

2．map（变换操作符）：对Observable发送的数据进行加工变换

3．filter（过滤操作符）：对Observable发送的数据按指定规则筛选

4．merge（组合操作符）：将多个Observable组合成一个单一的Observable。例如：{1,2,3} + {4,5,6} --> {1,2,3,4,5,6}

5．onError（异常处理操作符）：对异常处理

6．辅助操作符：辅助操作，一般用于对Observable处理

7．条件和布尔操作

8．算数 / 聚合操作 / 链接操作符

常用：

1．observeOn

线程转换符：指定数据接收线程，即指定Observer（Subscriber，Consumer……）接收数据在哪个线程。常用在后台（网络）处理完数据后需要在UI线程刷新（需要指定UI线程）的场景。每次指定一次都会生效。

2．subscribeOn

线程转换符：指定Observable数据流发送线程，即数据源发生的线程。多次指定只有第一次有效。

3．doOnEach

数据源（Observable）每发送一次数据之前都会调用一次，包括onNext、onError和 onComplete。

4．doOnNext

数据源每次调用onNext() 之前都会先回调该方法。

5．doAfterNext

数据源每次调用onNext() 之后都会先回调该方法。

6．doOnError

数据源每次调用onError() 之前会回调该方法。

7．doOnComplete

数据源每次调用onComplete() 之前会回调该方法

8．doOnSubscribe

数据源每次调用onSubscribe() 之后，发送数据之前会回调该方法，该方法可以指定线程，在后面紧跟的 subscribeOn() 指定的线程中执行

9．doOnDispose

当观察者取消订阅Observable时被调用；Observable通过onError或者onComplete结束时，会取消订阅所有的Observer

10．doOnTerminate

当Observable 终止之前会被调用，无论是正常还是异常终止（onComplete，onError）

11．doAfterTerminate

当Observable终止之后会被调用，无论是正常还是异常终止（onComplete，onError）

12．doFinally

当Observable 终止之后会被调用（最后），无论是正常还是异常终止（onComplete，onError）

1．create（创建）：Obserable

create

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
        e.onNext(1);
        e.onNext(2);
        e.onNext(3);
        e.onComplete();
        e.onNext(4);
    }
}).subscribe(new Consumer<Integer>() {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.e("zhao", "accept: " + integer);
    }
});

1）在调用 e.onComplete() 方法之后结束发送数据。e.onNext(4) 没有执行。

2) 在RxJava 2.x中，可以看到发送事件方法相比1.x多了一个throws Excetion，意味着我们做一些特定操作再也不用try-catch了。

3）接受数据可以用Observer或者Consumer（消费者），Consumer 对象是 Rxjava 2.x 特有。

defer（懒加载）

在观察者订阅之前不创建这个Observable；为每个观察者创建一个独立的新的Observable，表面上看每个订阅者都以为自己订阅的是同一个Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。

Observable<Integer> observable =
        Observable.defer(new Supplier<ObservableSource<Integer>>() {
            @Override
            public ObservableSource<Integer> get() throws Exception {
                return Observable.just(0, 1, 2, 3);
            }
        });
observable.subscribe(getObserver(0));
observable.subscribe(getObserver(1));

输出：

0：onSubscribe onNext:0 onNext:1 onNext:2 onNext:3 onComplete

1：onSubscribe onNext:0 onNext:1 onNext:2 onNext:3 onComplete

just

just将单个数据（将数组或Iterable当做单个数据）转换为发送数据的Observable。just类似于from，但是from会将数组或iterable的数据取出然后逐个生成Observable发送；但是just会将整个数据对象发送出去。

注意：传null给just，会返回一个发送null值（非空）的Observable。

Observable.just("Hello,I am China!")

        // Consumer替代1.x中的action1,接收一个参数
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("consumer", s);
            }
        };

rang(int start, int count)

操作符创建一个发送指定范围的整数序列的Observable，参数分别为起始值和长度。如果将第二个参数设为0，将导致Observable不发送任何数据（如果设置为负数，会抛异常）

range可以通过可选参数指定Scheduler。

Observable.range(1, 5)

        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
            }
        });

empty

无数据正常终止

创建一个不发送任何数据但是正常终止的Observable

Observable. empty ().subscribe(new Observer<Object>() {

    @Override
    public void onError(Throwable e) {}
    @Override
    public void onSubscribe(Disposable d) {}
    @Override
    public void onNext(Object o) {}
    @Override
    public void onComplete() {}
});

never

无数据不终止

创建一个不发送数据也不终止的Observable

Observable.never().subscribe(new Observer<Object>() {

    @Override
    public void onError(Throwable e) {}
    @Override
    public void onSubscribe(Disposable d) {}
    @Override
    public void onNext(Object o) {}
    @Override
    public void onComplete() {}
});

error

无数据错误终止

创建一个不发送数据并以一个错误终止的Observable

Observable. error ().subscribe(new Observer<Object>() {

    @Override
    public void onError(Throwable e) {}
    @Override
    public void onSubscribe(Disposable d) {}
    @Override
    public void onNext(Object o) {}
    @Override
    public void onComplete() {}
});

from

将一个Iterable, 一个Future, 或者一个数组转换成一个Observable。from操作符用来将某个对象转化为Observable对象，并且依次将其内容发送出去。这个类似于just，但是just会将数据对象整个发送出去。比如说一个含有10个数字的数组，使用from就会发送10次，每次发送一个数字，而使用just会发送一次来将整个的数组发送出去。

fromArray

创建一个Observable，接受一个数组，并将数组中的数据逐一发送

fromIterable

创建一个Observable，接受一个可迭代对象（实现Interable接口的类，如List/Map/Set），并将可迭代对象中的数据逐一发送

fromFuture(Future)

对于Future，它会发送Future.get()方法返回的单个数据。

fromFuture（Future，Long，TimeUtil）

fromFuture可以参数指定超时时长和时间单位，如果过了指定的时长Future还没有返回一个值，这个Observable会发送错误通知并终止。

interval

interval操作符返回一个Observable，它按固定的时间间隔发送一个无限递增的整数序列（0,1,2,3,4,5,6……）

interval(long period, @NonNull TimeUnit unit)

Observable

        .interval(1000, TimeUnit.MINUTES)
        .subscribe(new Observer<Object>())

延迟1000ms，发送0；延迟1000ms，发送1 ……

public static Observable<Long> interval(long period, @NonNull TimeUnit unit) {

    return interval(period, period, unit, Schedulers.computation());
}

interval(long initialDelay, long period, @NonNull TimeUnit unit)

指定延迟之后，发送第一个数据0；然后再按照指定的时间间隔发送递增的数字。

Observable

        .interval(1000,1000,TimeUnit.MILLISECONDS)
        .subscribe(new Observer<Object>()

interval(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)

interval默认线程：computation。也可以通过参数来指定调度器。

intervalRange(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit)

指定起始值和长度

类似interval 做周期性操作的例子，如果并没有使之停下来的方式，没有去控制订阅的生命周期，这样，就有可能引发内存泄漏。所以，在 Activity 的 onDestroy() 方法执行的时候或者不需要继续执行的时候应该解除订阅。

repeat

它不是创建一个Observable，而是重复发送原始Observable的数据序列，这个序列可以是无限的：

Observable

        .just(1,2,3,4)
        .repeat()

repeat(long times)

通过repeat(n)指定重复次数。

Observable

        .just(1,2,3,4)
        .repeat(5)

repeatUntil(@NonNull BooleanSupplier stop)

一直重复，直到条件返回true！（条件默认返回false，即不停止重复）

Observable.just(1,3).repeatUntil(new BooleanSupplier() {

    @Override
    public boolean getAsBoolean() throws Throwable {
        return false;
    }
});

默认线程trampoline。可以通过可选参数指定Scheduler。

repeatWhen(@NonNull Function<? super Observable<Throwable>, ? extends ObservableSource<?>> fun)

repeatWhen操作符提供了重订阅功能。

Function输入是一个Observable<Object>，输出是一个泛型ObservableSource<?>。Function只在onComplete的时候触发，它不会收到任何的onNext事件。

repeatWhen通过返回一个ObservableSource<?>来通知订阅者，如果该ObservableSource返回onComplete/onError，则不会触发重订阅；如果发送onNext，则触发重订阅。

retryWhen针对onError触发重订阅条件；repeatWhen针对onComplete触发重订阅条件。

timer

timer返回一个Observable，它在延迟一段给定的时间后发送一个简单的数字0。默认线程computation。通过可选参数指定Scheduler。

timer操作符通常用于实现延迟，类似于Thread.sleep(n);

Observable

        .timer(1000, TimeUnit.MILLISECONDS)
        .subscribe(new Observer<Object>())

2．map（变换）：Data（数据）

把原数据源变换成新的数据源。对Observable发送的每一项数据按照既定规则执行变换操作后再发出。

map（转换）

对数据源的每一项数据应用一个函数，执行加工变换后返回一个新的数据类型。可以看做是一个数据加工流水线上的一个加工点。

map操作符：需要接收一个函数接口Function<T, R> 的实例化对象，实现接口内R apply(T t) 的方法，在此方法中可以对接收到的数据t进行变换后返回。

cast操作符【强制转换操作符】：将原始Observable发送的每一项数据都强制转换为一个指定的类型（多态），然后再发送数据，它是map的一个特殊版本。

模型：输入（事件，数据）——> map（加工，转换）——> 输出（return）

Observable.just("images/logo.png") // 输入类型 String

        .map(new Function<String, Bitmap>() {
            @Override
            public Bitmap apply(String filePath) throws Exception {
                // TODO Auto-generated method stub
                return null;
            }
        }).subscribe(new Consumer<Bitmap>() {
    @Override
    public void accept(Bitmap bitmap) throws Exception {
        // TODO Auto-generated method stub
    }
});

Observable ——> 参数输入(String) ——> map ——> 参数输出(Bitmap) ——> Observer

上述代码中，map() 方法将参数中的 String 对象转换成一个 Bitmap 对象后返回，而在经过 map() 方法后，事件的参数类型也由 String转为了 Bitmap。Function的泛型第一个为接收参数的数据类型，第二个为转换后要发送的数据类型。这种直接变换对象并返回的，是最常见的也最容易理解的变换。不过 RxJava 的变换远不止这样，它不仅可以针对事件对象，还可以针对整个事件队列，这使得 RxJava 变得非常灵活。

map()：可以理解成映射、变换:（事件对象的直接变换），它是 RxJava 最常用的变换。

flatMap（转换）

map操作符：实现的是一对一的转换，会对每一条输入应用Function，然后返回一个Observable对象。即数据源发送了多少条数据给map加工，map就返回了多少个Observable

flatMap操作符：先执行map的操作，之后把多个结果Observable汇入同一个Observable统一对结果数据进行下发

flatMap的原理：

1. 使用传入的事件（单个数据项）创建一个 Observable 对象，激活并使它开始发送事件；

2. 每一个创建出来的 Observable 发送的事件，转换（应用Function）后汇入同一个 Observable ，而这个 Observable 负责将这些事件统一发放。

flatMap把事件拆成了两级，通过一组新创建的 Observable 将初始的对象『铺平』之后通过统一路径（汇入同一个Observable）分发了下去。而这个『铺平』就是 flatMap() 所谓的 flat。

flatMap并不能保证事件的顺序，如果需要保证，需要用到concatMap。

举例，打印一组学生的课程名：

Student[] students = ...;

Observable.fromArray(students)
        .flatMap(new Function<Student, Observable<Course>>() {
            @Override
            public Observable<Course> apply(Student student) {
                return Observable.fromArray(student.getCourses());
            }
        })
        .subscribe(new Observer<Course>() {
            @Override
            public void onNext(Course course) {
                Log.d(tag, course.getName());
            }
        });

扩展：由于可以在嵌套的 Observable 中添加异步代码， flatMap() 也常用于嵌套的异步操作，例如嵌套的网络请求。