RxJava2最全面、最详细的讲解（四）

最新推荐文章于 2024-05-14 02:14:33 发布
最新推荐文章于 2024-05-14 02:14:33 发布
阅读量1.5k 收藏 16
点赞数 8
分类专栏： Android网络请求相关 文章标签： rxjava使用 安卓rxjava rxjava详解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37796683/article/details/102718718
版权

前言：及时当勉励，岁月不饶人，生命不止，奋斗不息，比自己差的人还没有放弃，比自己强的人还在努力！

一、概述

RxJava2在第一篇文章作了详细的介绍，第二篇文章中讲解了RxJava的变换操作符，组合操作符，合并操作符；第三篇讲解了延迟、do相关、错误处理等操作符的使用，如果英文比较好而且有兴趣的可以到官网学习：ReactiveX的官方网站。下面开始继续讲解RxJava2的其他用法。（链接和源码在文章最后给出）

二、过滤操作符

1.filter()

filter()对源Observable(被观察者)产生的结果按照执行条件过虑，只有满足条件才会提交给观察者。

Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
            .filter(new Predicate<Integer>() {
        @Override
        public boolean test(Integer integer) throws Exception {
            //条件：能否被2整除
            return integer % 2 == 0;
        }
    }).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "filter：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "filter：apply == 事件" + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "filter：onComplete == ");
        }
    });

例子中放1~9共9个数据，在filter回调方法中添加条件判断，满足则将结果发送给观察者，满足能被2整除的数是：2,4,6,8；打印数据如下：

2.ofType()

ofType()根据类型对源Observable(被观察者)产生的结果进行过滤，只有满足条件才会提交给观察者Observer。ofType()与filter()类似，但是ofType()是根据类型对结果进行过滤的。

Observable.just(1, "大闸蟹", true, 0.23f, 5L, new Goods("商品名"))
            .ofType(Goods.class).subscribe(new Observer<Goods>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "ofType：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Goods goods) {
            Log.e(TAG, "ofType：onNext == " + goods.getName());
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "ofType：onComplete == ");
        }
    });

这里事件队列有多种类型，int、String、Boolean、float、Long还有自定义的实体类，过滤实体类的数据Goods.calss，打印数据如下：

3.elementAt()

elementAt()把源Observable（被观察者）生产的结果中，只提交索引指示的结果给Observer（观察者）。注意：索引从0开始。

Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9)
             .elementAt(7)
             .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "elementAt：accept == " + integer);
        }
    });

这里打印索引（索引从0开始计算）为7的数据：8，打印数据如下：

4.distinct()

distinct()：对源Observable的结果进行过滤，去掉重复出现的结果，只输出不重复的结果给Observer观察者，简单来说就是去重。

Observable.just(1, 2, 2, 3, 4, 4, 4)
             .distinct()
                .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "distinct：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "distinct：onNext == " + integer);

        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "distinct：onComplete == ");
        }
    });

这里的事件队列中，2和4皆有多个重复的数据，如果过滤重复的那么只会出现：1,2,3,4，打印数据如下：

5. debounce()

debounce()：只接收到倒计时时间外的源Observable(被观察者)发出的事件，每次发送的事件都会重置倒计时时间。

 Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) {
            try {//产生结果的时间间隔为0,100,200……900毫秒，每次发送的数据为0,1,2……9
                for (int i = 0; i < 10; i++) {
                    e.onNext(i);
                    Thread.sleep(i * 100);
                }
            } catch (Exception exception) {
                e.onError(exception);
            }
        }
    }).debounce(300, TimeUnit.MILLISECONDS)
                .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "debounce：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "debounce：onNext ==" + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "debounce：onComplete == ");
        }
    });

这里每隔0,100,200……900毫秒发送的数据分别为0,1,2……9，debounce()中指定倒计时的时间为300毫秒，只接受到300毫秒后的结果，打印数据如下：

6.first()

first()：将源Observable(被观察者)产生的第一次结果提交给Observer(被观察者)，first()可以用elementAt(0)和take(1)替代。

  • first(T defaultItem)：defaultItem表示默认值。
  Observable.just(1,2,3)
            .first(0)//defaultItem：默认值
                .subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {
            Log.e(TAG, "first：accept ==" + integer);
        }
    });

这里发送1,2,3，接受到第一个结果为：1，如果接受不到数据则直接输出默认值，这里设置的默认值为0，打印数据如下：

7.last()

last()：表示将源Observable(被观察者)产生的最后一次结果提交给Observer(被观察者)，与first()相对应，可以用takelast()替代。

Observable.just(1, 2, 3, 4)
        .last(-1)
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "last：accept ==" + integer);
              }
        });

发出4个事件，返回最后一个事件的结果：4，默认值为-1（在获取不到结果的时候返回），打印结果如下：

8.skip()

skip()：针对源Observable(被观察者)产生的结果跳过N个不处理，而把后面的结果提交给Observer(观察者)处理。与takeLast()类似。

Observable.just(1, 2, 3, 4, 5, 6, 7)
         .skip(3)
         .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "skip：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "skip：onNext ==" + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "skip：onComplete == ");
        }
    });

这里发送7个事件，跳过前三个，打印数据如下：

9.take()

take()：源Observable(被观察者)产生的结果，把前面的n个提交给Observer(观察者)处理，后面的不做处理。与skip()相对。

 Observable.just(1, 2, 3, 4, 5, 6, 7)
         .take(3)
         .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "take：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "take：onNext ==" + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "take：onComplete == ");
        }
    });

这里发送了7个事件，只提交前面三个数据给Observer，打印数据如下：

takeLast()表示把最后的n项结果提交给Observer，与skip()类似，这里就不举例了。

这里对过滤操作符做一个简单的总结：

创建类型作用备注使用场景
过滤操作符filter()按照指定的条件(自定义)对被观察者发出的结果进行过滤，再提交给被观察者在回调方法中实现规则过滤

需要过滤或者选择某一步操作

ofType()根据指定的数据类型对被观察者发出的结果进行过滤，再提交给被观察者参数传入对结果过滤的类型
elementAt()将指定索引被观察者发出的事件提交给观察者，索引为0参数传入索引
distinct()去重，去掉被观察者产生的重复的结果，将不重复的提交给观察者
debounce()只接收到倒计时时间外的被观察者发出的事件，每个事件发出时会重置倒计时时间。参数传入每个事件的倒计时时间
first()将被观察者产生的第一个结果提交给被观察者处理
last()将被观察者产生的最后一个结果提交给观察者处理
skip()跳过前n个被观察者产生的结果，将后面的提交给观察者处理参数传入指定跳过的数量
take()将前n个被观察者产生的结果提交给观察者处理，其他的不做处理参数传入指定执行的数量

三、其他他操作符

1.groupBy()

groupBy()：对于源Observable(被观察者)产生的结果进行分组，形成一个类型为GroupedObservable的结果集，GroupedObservable存在一个方法为getKey()，通过该方法获取结果集的key值。

注意：由于结果集GroupedObservable把分组结果缓存起来，如果对每个GroupedObservable都不进行处理（既不订阅也没有别的操作）就有可能出现内存泄漏，如果某个GroupedObservable不处理那可以使用take(0)处理掉。

//每隔一秒发送一次事件，一共发送五次
Observable.interval(1, TimeUnit.SECONDS)
            .take(5)
            .groupBy(new Function<Long, Object>() {
        @Override
        public Object apply(Long aLong) throws Exception {
            return aLong * 10;
        }
    }).subscribe(new Observer<GroupedObservable<Object, Long>>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "take：onSubscribe == 订阅");
        }

        @Override
        public void onNext(GroupedObservable<Object, Long> objectLongGroupedObservable) {
            Log.e(TAG, "take：onNext == key:" + objectLongGroupedObservable.getKey());
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "take：onComplete == ");
        }
    });

这里每隔1秒发送一次事件，一共发送五次，key值*10处理，打印结果如下：

2.cast()

cast()：主要是用于类型转换的，传入的参数类型为.class,如果源Observable(被观察者)的源类型不能转为指定的.class,  则会抛出ClassCastException类型转换异常。

 Observable.just(1, 2, 3, 4, 5, 6)
         .cast(Integer.class)
         .subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "cast：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "cast：onNext == " + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "cast：onComplete == ");
        }
    });

这里发出1~6个事件，打印数据如下：

3.scan()

scan()：通过遍历源Observable(被观察者)产生的结果，依次每个结果按照指定的规则进行计算，计算后的结果作为下一项迭代的参数，每一次迭代项都会把计算结果输出给订阅者。简单来说就是每次计算后的结果都会用于下一次计算。

 Observable.just(1, 2, 3)
         .scan(new BiFunction<Integer, Integer, Integer>() {
        @Override
        public Integer apply(Integer sum, Integer integer) throws Exception {
            //sum是上次计算的记过，integer是本次计算的参数
            Log.e(TAG, "scan：apply == sum + integer = " + sum + " + " + integer);
            return sum + integer;
        }
    }).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "scan：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "scan：onNext == " + integer);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "scan：onComplete == ");
        }
    });

这里只有1,2,3共三个事件，第一次计算：0+1；第二次计算：第一次计算的结果+第二个参数，即：1+2=3；第三次计算：上一次计算的结果+第三个参数，即：3+3=6，打印数据如下：

4.join()

join()：把两个Observable(被观察者)产生的结果进行合并，合并成的结果组成一个新的Observable，可以控制每个Observable产生结果的生命周期，在每个结果的生命周期内，可以与另一个Observable产生的结果按照一定的规则进行合并。类似combineLatest()。

join()的用法如下：

ObservableA.join(ObservableB, ObservableA产生结果的生命周期控制函数，ObservableB产生结果的生命周期控制函数, ObservableA与ObservableB结果合并规则函数)

    //每隔一秒，产生0,5,10,15,20事件队列
    Observable<Long> observable1 = Observable.interval(0,1000, TimeUnit.MILLISECONDS)
            .map(new Function<Long, Long>() {
                @Override
                public Long apply(Long aLong) throws Exception {
                    return aLong * 5;
                }
            }).take(5);

    //延时500毫秒，每隔一秒，产生0,10,20,30,40 事件队列
    Observable<Long> observable2 = Observable.interval(500, 1000,TimeUnit.MILLISECONDS)
            .map(new Function<Long, Long>() {
                @Override
                public Long apply(Long aLong) {
                    return aLong * 10;
                }
            }).take(5);


    observable1.join(observable2, new Function<Long, ObservableSource<Long>>() {
        @Override
        public ObservableSource<Long> apply(Long aLong) {
            //使Observable延时600毫秒执行(控制observable1的生命周期)
            return Observable.just(aLong).delay(600,TimeUnit.MILLISECONDS);
        }
    }, new Function<Long, ObservableSource<Long>>() {
        @Override
        public ObservableSource<Long> apply(Long aLong) {
            //使Observable延时600毫秒执行(控制observable2的生命周期)
            return Observable.just(aLong).delay(600,TimeUnit.MILLISECONDS);
        }
    }, new BiFunction<Long, Long, Long>() {
        @Override
        public Long apply(Long aLong, Long aLong2) {
            //合并逻辑
            Log.e(TAG, "BiFunction：apply == aLong1 + aLong2：" + aLong + " + " + aLong2);
            return aLong + aLong2;
        }
    }).subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "join：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "join：onNext == " + aLong);
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "join：onComplete == ");
        }
    });

Observable1每隔1秒产生0,5,10,15,20 事件队列，Observable2延时0.5秒，每隔1秒产生0,10,20,30,40 事件队列，第一个Function函数控制Observable1结果的生命周期，第二个Function函数控制Observable2结果的生命周期，都做了延时600毫秒发送，第三个BiFunction函数整合Observable1，Observable2产生的结果，打印数据如下：

5.groupJoin()

groupJoin()：类似于join()，也是把两个Observable产生的结果进行合并，组成一个新的Observable，可以控制每个Observable产生结果的生命周期，在每个结果的生命周期内，与另一个Observable的结果进行合并按照一定的规则进行合并。与join()不同的是第四个参数传入的函数不一致。

   //每隔1秒，产生0,5,10,15,20事件队列
    Observable<Long> observable1 = Observable.interval(0, 1000, TimeUnit.MILLISECONDS)
            .map(new Function<Long, Long>() {
                @Override
                public Long apply(Long aLong) {
                    return aLong * 5;
                }
            }).take(5);

    //延迟0.5秒，每秒产生0,10,20,30,40事件队列
    Observable<Long> observable2 = Observable.interval(500, 1000, TimeUnit.MILLISECONDS)
            .map(new Function<Long, Long>() {
                @Override
                public Long apply(Long aLong) {
                    return aLong * 10;
                }
            }).take(5);

        observable1.groupJoin(observable2, new Function<Long, ObservableSource<Long>>() {
        @Override
        public ObservableSource<Long> apply(Long aLong) {
            //使Observable延时1600毫秒执行(控制observable1的生命周期)
            return Observable.just(aLong).delay(1600, TimeUnit.MILLISECONDS);
        }
    }, new Function<Long, ObservableSource<Long>>() {
        @Override
        public ObservableSource<Long> apply(Long aLong) {
            //使Observable延时600毫秒执行(控制observable2的生命周期)
            return Observable.just(aLong).delay(600, TimeUnit.MILLISECONDS);
        }
    }, new BiFunction<Long, Observable<Long>, Observable<Long>>() {
        @Override
        public Observable<Long> apply(final Long aLong, Observable<Long> longObservable) {
            return longObservable.map(new Function<Long, Long>() {
                @Override
                public Long apply(Long aLong2) {
                    //合并逻辑
                    Log.e(TAG, "BiFunction：apply == aLong1 + aLong2：" + aLong + " + " + aLong2);
                    return aLong + aLong2;
                }
            });
        }
    }).subscribe(new Observer<Observable<Long>>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "groupJoin：onSubscribe == 订阅");
        }

        @Override
        public void onNext(Observable<Long> longObservable) {
            longObservable.subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    Log.e(TAG, "groupJoin：onNext == " + aLong);
                }
            });
        }

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

        @Override
        public void onComplete() {
            Log.e(TAG, "groupJoin：onComplete == ");
        }
    });

Observable1每隔1秒产生0,5,10,15,20事件队列，Observable2延时0.5秒，每隔一秒产生0,10,20,30,40事件队列，第一个Function函数控制Observable1结果的生命周期，第二个Function函数控制Observable2结果的生命周期，第三个函数BiFunction整合Observable1和Observable2的结果，返回的结果是新的Observable。打印结果如下：

我们来对这部分的操作符做个小结：

创建类型作用备注
过滤操作符groupBy()对于源Observable(被观察者)产生的结果进行分组，形成一个类型为GroupedObservable的结果集，存在一个方法为getKey()，通过该方法获取结果集的key值如果事件结果没有处理，那么take()处理一下，否则会内存泄漏
cast()用于类型转换，将源Observable的源类型转为指定的.class如果类型不正确则会抛出转换异常。
scan()遍历源Observable产生的结果，依次每个结果按照指定的规则进行计算，计算后的结果作为下一项迭代的参数，每一次迭代项都会把计算结果输出给订阅者。每次计算的结果用于下次计算
join()把两个Observable产生的结果进行合并，合并结果组成一个新的Observable，可以控制每个Observable产生结果的生命周期，在每个结果的生命周期内，可以与另一个Observable产生的结果按照一定的规则进行合并合并结果产生新的Observable
groupJoin()类似上述，第三个参数不一致，返回新的Observable处理

源码地址：https://github.com/FollowExcellence/Rxjava_Retrofit

点关注，不迷路

好了各位，以上就是这篇文章的全部内容了，能看到这里的人呀，都是人才。

我是suming，感谢各位的支持和认可，您的点赞、评论、收藏【一键三连】就是我创作的最大动力，我们下篇文章见！

如果本篇博客有任何错误，请批评指教，不胜感激 ！

要想成为一个优秀的安卓开发者，这里有必须要掌握的知识架构，一步一步朝着自己的梦想前进！Keep Moving!

相关文章：

Retrofit2详解和使用（一）

  • Retrofit2的介绍和简单使用

OKHttp3的使用和详解

  • OKHttp3的用法介绍和解析

OKHttp3源码详解

  • 从源码角度解释OKHttp3的关键流程和重要操作

RxJava2详解（一）

  • 详细介绍了RxJava的使用（基本创建、快速创建、延迟创建等操作符）

RxJava2详解（二）

  • RxJava转换、组合、合并等操作符的使用

RxJava2详解（三）

  • RxJava延迟、do相关、错误处理等操作符的使用

RxJava2详解（四）

  • RxJava过滤、其他操作符的使用

上述几篇都是android开发必须掌握的，后续会完善其他部分！

苏火火丶
关注
  • 8
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava讲解视频
11-09
里面有百度云盘的视频下载地址。用五节课让你对RxJava有一个全面的认识。
RxJava入门学习资料-RxJava Essentials(英/中文版合集)
05-01
总的来说，《RxJava Essentials》是一本全面的教程，可以帮助读者掌握 RxJava 的基本原理和实用技巧，从而更好地利用响应式编程提升开发效率和代码质量。通过深入学习这本书，你将能够熟练地运用 RxJava 解决实际...
RxJava2最全面、最详细的讲解（二）
https://juejin.cn/user/1654096907477549/posts
10-17 5898
前言：九牛一毫莫自夸，骄傲自满必翻车，历览古今多少事，成由谦逊败由奢。 一、概述 RxJava2在第一篇文章中基本用法作了详细的介绍，是一个基于事件流的异步操作库。相信大家对RxJava有了一定的理解，由于篇幅过长所以重新写了一篇，如果不了解Rxjava2可以参考下RxJava2最全面、最详细的讲解(一)。下面开始继续讲解RxJava2的其他用法。(源码和其他链接在文章最后给出) 在使用...
RxJava 2.0 全体系梳理(持续更新ing)
化身孤岛的瓜
07-02 1611
只有观察者订阅了，才开始执行发射数据的代码。并且Cold Observable和Observer只能是一对一的关系。当有多个不同的订阅者时，消息是重新完整发送的，也就是说，对于Cold Observeable来说，有多个Observer存在的时候，各自的事件是独立的。多个订阅的sunbscribe（或者说观察者）事件各自独立。Hot Observable 无论有没有观察者订阅，事件始终都会发生。当Hot Observable有多个订阅者时，Hot Observable与订阅者们的关系是一对多的关系。
2024年Android最全RxJava2 源码解析（二）(1)，2024年最新开发人员必学
最新发布
2401_84557161的博客
05-14 830
一下。
Android最火的框架系列（九）RxJava2
zhaojun的博客
08-18 2万+
RxJava是一套响应式编程技术，实现业务和逻辑上的链式编程。RxJava和RxJava2的使用会有一些区别，这篇博客基于RxJava2。我将总结一下RxJava2的使用，整理一下RxJava2常用的操作符，针对每个操作符，都会有相应的代码，帮助我们理解。 一.RxJava概论 RxJava也是基于观察者模式：被观察者完成计算任务，观察者根据被观察者的计算结果作...
RxJava2使用归纳总结
dreams_deng的博客
03-09 1156
RXJava角色划分： observale: 被观察者 observer: 观察者 子类Subject【科目】 subscribe: 订阅 被观察者.订阅(观察者),被观察者通知观察者 被观察者类型： 热： 订阅完毕立即发送数据 冷： 创建以后，等待观察者订阅， 一旦订阅了，才发送数据 1. ...
RxJava 入门和常见使用方式
weixin_34210740的博客
06-06 310
本文由玉刚说写作平台提供写作赞助，版权归玉刚说微信公众号所有 原作者：ZedeChan 版权声明：未经玉刚说许可，不得以任何形式转载 0. 简介 RxJava 其实就是提供一套异步编程的 API，这套 API 是基于观察者模式的，而且是链式调用的，所以使用 RxJava 编写的代码的逻辑会非常简洁。 RxJava 有以下三个基本的元素： 被观察者（Observable） 观察者（Observer...
四本安卓书籍
11-02
2. **用户界面设计**：讲解如何使用XML布局文件创建用户界面，包括各种控件的使用、适配器和ListView的集成，以及Material Design的设计原则。 3. **数据存储**：介绍SQLite数据库的使用，如何进行数据操作，以及...
RxJava2 只看这一篇文章就够了
BASK2312的博客
06-07 229
RxJava 其实就是提供一套异步编程的 API，这套 API 是基于观察者模式的，而且是链式调用的，所以使用 RxJava 编写的代码的逻辑会非常简洁。下面来说说以上三者是如何协作的：首先在 gradle 文件中添加依赖：arduino复制代码scss复制代码typescript复制代码ini复制代码这里其实也可以使用链式调用：typescript复制代码。
RxJava2最全面、最详细的讲解（三）
https://juejin.cn/user/1654096907477549/posts
10-22 2430
前言：不要在该奋斗的年纪去选择安逸享乐，不是每个人都能成为自己想要的样子，但是每个人都能努力成为自己想要的样子，相信自己，你能作茧自缚，最终也能破茧成蝶。 —— 致正在努力奋斗打拼的人 一、概述 RxJava如此受欢迎，是因为提供了丰富且功能强大的操作符，几乎能完成所有...
【Android -- 开源库】RxJava2.0 响应式编程
Kevin Learn Android
05-03 3338
目前 RxJava 最新版本是 V3.0.11。 RxJava2 有以下三个基本的元素： 1. 被观察者（Observable） 2. 观察者（Observer） 3. 订阅（subscribe）
RxJava2
来啊 快活啊
03-17 751
在RxJava中，函数响应式编程具体表现为一个观察者（Observer）订阅一个可观察对象（Observable），通过创建可观察对象发射数据流，经过一系列操作符（Operators）加工处理和线程调度器（Scheduler）在不同线程间的转发，最后由观察者接受并做出响应的一个过程 ObservableSource与Observer是RxJava2中最典型的一组观察者与可观察对象的组合，其他四组...
RxJava 2.0 使用详解
热门推荐
苦逼的程序猿☺
11-29 4万+
前言在上一篇博客中，提到了RxJava的一些比较核心的东西，还有与1.x版本的一些区别！ 现在我们具体了解一下它的使用！使用最基本的的使用我们知道一个简单的RxJava的应用，需要一个观察者或者订阅者Observer，一个被观察者Observable，最后调用subscribe()方法将两者绑定起来！ 示例：//创建观察者或者订阅者 Observer observer = new
RxJava2背压-Flowable
tinysakura的博客
02-25 1163
转载自冯丰枫的博客 Flowable介绍 既然在函数响应式编程中会产生背压（backpressure）问题，那么在函数响应式编程中就应该有解决方案。 Rxjava2相对于Rxjava1最大的更新就是把对背压问题的处理逻辑从Observable中抽取出来产生了新的可观察对象Flowable。 在Rxjava2中，Flowable可以看做是为了解决背压问题，在Observable的基础上优化后的产物，...
RxJava2最全面、最详细的讲解（一）
qq_32534441的博客
03-13 8696
一、概述 提高开发效果，降低维护成本一直是团队追求的宗旨。现在安卓里面RxJava2+Retrofit+OKHttp的网络请求框架是最流行的，几乎一统江湖，配合响应式式编程的RxJava使用也越来越多。如果英文比较好而且有兴趣的可以到官网学习：ReactiveX的官方网站。（源码和其他相关链接在文章最后给出） RxJava到底是什么？       RxJava在Git...
【Rxjava详解】(二) 操作符的妙用
xoliu的博客
11-23 418
RxJava提供了丰富的操作符来处理和转换数据流。操作符是 RxJava 的核心组成部分，它们提供了一种灵活、可组合的方式来处理数据流，使得开发者可以更加便捷地进行数据处理和流程控制。
rxjava背压_RxJava2实战--第八章 RxJava的背压
weixin_39820177的博客
12-18 197
RxJava2实战--第八章 RxJava的背压1 背压在RxJava中，会遇到被观察者发送消息太快以至于它的操作符或者订阅者不能及时处理相关的消息，这就是典型的背压(Back Pressure)场景。BackPressure经常被翻译为背压，背压的字面意思比较晦涩，难以理解。它是指在异步场景下，被观察者发送事件速度远快于观察者处理的速度，从而导致下游的buffer溢出，这种现象叫做背压。产生条件...
rxjava2 defer
07-28
引用\[2\]:上面我们介绍了了关于RxJava的基本的概念和使用方式，在下面的文章中我们会按照以上定义的顺序从API的角度来讲解以下RxJava各个模块的使用方法。引用\[3\]:retry使用了一种错误重试机制，它可以在出现错误...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值