【Android】写给小白的RxJava教程（三）

最新推荐文章于 2024-04-14 18:01:38 发布

Coder .

最新推荐文章于 2024-04-14 18:01:38 发布

阅读量1.6k

点赞数 18

分类专栏： Android

本文链接：https://blog.csdn.net/weixin_43927892/article/details/106334719

版权

Android 专栏收录该内容

34 篇文章 4 订阅

订阅专栏

简介：大三学生党一枚！主攻Android开发，乐于交友一起学习！
个人语录：取乎其上，得乎其中，取乎其中，得乎其下，以顶级态度写好一篇的博客。

RxJava教程（三）

一.RxJava中的创建操作符
二.RxJava中的变换操作符
三.总结

一.RxJava中的创建操作符

什么是创建操作符？简而言之，就是会返回一个Observable对象，并且经过该方法的特殊处理。

1.1 create

普通的创建一个Observable对象

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter e) throws Exception {
                e.onNext(1);
                Log.d("create", "subscribe: "+1);
                e.onNext(2);
                Log.d("create", "subscribe: "+2);
                e.onNext(3);
                Log.d("create", "subscribe: "+3);
            }
        }).subscribe(new Observer<Integer>() {
            Disposable d;
            @Override
            public void onSubscribe(Disposable d) {
                this.d=d;
            }

            @Override
            public void onNext(Integer integer) {
                Log.d("create", "onNext: "+integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

在这里插入图片描述
如果没有要求，就使用create方法创建Observable对象。

1.2 just

使用just创建，可以传入任意类型的对象列表，并会依次传递给观察者，适合只有onNext事件的被观察者。

 private void LogByJust(){
        Observable.just("张三","李四").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                Log.d("just", "onNext: "+s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

在这里插入图片描述

1.3 interval

该方法用于周期性的执行某个方法，传入一个间隔周期，并指定单位，可以是秒，分钟，小时和天。

 private void LogByInterval(){
        Observable.interval(3, TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.d("interval", "onNext: "+aLong);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

在这里插入图片描述
此方法不依赖当前的Activity，即使活动被销毁，他仍会执行周期性的任务，如果是更新UI操作，当退出当前Activity时，会自动停止，也不会抛出异常！

1.4 range

range可以指定一个开始和count,比如说从1开始，数目为10

private void LogByRange(){
        Observable.range(1, 10)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d("range", "onNext: "+integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

在这里插入图片描述
我感觉这个功能和for循环差不多哈哈哈

1.5 timer

倒计时，传入一个时间，前面是数值，后面是单位。延迟这么久以后执行任务。

private void LogByTimer() {

        Observable.timer(5, TimeUnit.SECONDS)
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Long aLong) {
                        Log.d(TAG, "onNext: "+aLong);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

常用的创建操作符就以上。Retrofit2.0和之前的版本差别挺大的！！！
个人感觉RxJava中的操作符就和Python中的方法一样，要是完全写出来，都能写一本书，所以建议还是用到的时候再去查，没必要面面俱到，真没必要！
在这里插入图片描述

在这里插入图片描述

二.RxJava中的变换操作符

2.1 map

map操作符使用过指定一个Function方法，将Observable转换成一个新的Observable对象并发射，就相当于我们访问网站被中间人篡改了网站信息进到了钓鱼网站，我们本来发射的是www.baidu.com.经过map操作以后，对原始内容进行了修改，最后我们发射到了腾讯的网站。看代码：

 private void LogByMap() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("www.baidu.com");
            }
        }).map(new Function<String, String>() {
            @Override
            public String apply(String s) throws Exception {
                return s+"www.tencent.com";
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

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

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

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

2.2 flatMap

flatMap操作符将Observable发射的数据集合变换为Observable集合，然后将这些Observable发射的数据平坦的放进一个单独的Observable。

 private void LogByFlatMap(){
       Observable.create(new ObservableOnSubscribe<String>() {
           @Override
           public void subscribe(ObservableEmitter<String> e) throws Exception {
               e.onNext("baidu");
               //发送的每一个事件都会经过flatMap的转换
               e.onNext("tencent");
               e.onNext("jd");
           }
       }).flatMap(new Function<String, ObservableSource<String>>() {
       //funtion的第一个参数是我们发射过来数据的类型
       //Observable中的参数类型是我们将要转变的类型

           @Override
           public ObservableSource<String> apply(String s) throws Exception {
           //apply中的类型是原始Observable发射的数据类型
           //Observable<String>是我们将要转变的数据类型
               return Observable.just("www."+s+".com");
               //返回的同样还是一个Observable，就相当于上游混浊的水经过中间一个自来水厂
               //变成了清澈的水，但是仍然还是水！自来水厂就相当于flatMap
           }
       }).subscribe(new Observer<String>() {
           @Override
           public void onSubscribe(Disposable d) {
         
           }

           @Override
           public void onNext(String s) {
               Log.d("flatMap", "onNext: "+s);
           }

           @Override
           public void onError(Throwable e) {

           }

           @Override
           public void onComplete() {

           }
       });
    }

在这里插入图片描述

FlatMap有点难懂，我们再举一个例子，假设有10名用户，每个人都有自己的编号，我们需要根据编号指定欢迎语。

private void LogByFlatMap2() {
        List<Integer> list = new ArrayList<>();
        for(int i=1;i<=10;i++){
            list.add(i);
        }
        Observable.fromIterable(list).flatMap(new Function<Integer, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                return  Observable.just("welcome to join us:"+integer);
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                Log.d("flatMap2", "onNext: "+s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

在这里插入图片描述
注意：flatMap的合并允许交叉，也就是说可能会交错的发送事件，最终的结果顺序可能并不是原始的Observable发送时的顺序！

2.3 concatMap

concatMap操作符功能和flatMap保持一致，他解决了flatMap交叉的问题，提供了一种能把发射的值连续在一起的函数，而不是合并他们。使用方法类似，这里不再贴代码。

2.4 flatMapIterable

该操作符可以将数据包装成Iterable在Iterable中我们就可以对数据进行处理了

 private void LogByFlatMapIterable() {

        Observable.just(1,2,3).flatMapIterable(new Function<Integer, Iterable<Integer>>() {
            @Override
            public Iterable<Integer> apply(Integer integer) throws Exception {
                List<Integer> list = new ArrayList<>();
                Log.d(TAG, "apply: ");
                list.add(integer);//1,2,3,所以这里会调用三次
                list.add(integer+1);
                return list;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(Integer integer) {
                Log.d("flatMapIterable", "onNext: "+integer);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });
    }

在这里插入图片描述

2.5 buffer

buffer操作符将源Observable变换为一个新的Observable，这个新的Observable每次发射一组列表，而不是一个个的发。

  private void LogByBuffer() {
        Observable.just(1,2,3,4,5,6)
                .buffer(3)
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        
                    }

                    @Override
                    public void onNext(List<Integer> integers) {
                       for(int i:integers){
                           Log.d(TAG, "onNext: "+i);
                       }
                        Log.d(TAG, "onNext: --------------------");
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

在这里插入图片描述

三.总结

关于RxJava的操作符还有很多，本篇主要介绍创建操作符和变换操作符，RxJava的内容很多，单独写都能写一本书，所以建议学习的时候不需要面面俱到，先会用，在熟练的用！

先别走，我有一个资源学习群要推荐给你，它是白嫖党的乐园，小白的天堂！
在这里插入图片描述
别再犹豫，一起来学习！

Coder .

关注

18
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
22
评论
【Android】写给小白的RxJava教程（三）

简介：大三学生党一枚！主攻Android开发，乐于交友一起学习！个人语录：取乎其上，得乎其中，取乎其中，得乎其下，以顶级态度写好一篇的博客。RxJava教程（三）一.RxJava中的创建操作符1.1 create1.2 just1.3 interval1.4 range1.5 timer2.1 map2.2 flatMap2.3 concatMap2.4 flatMapIterable2.5 buffer三.总结一.RxJava中的创建操作符什么是创建操作符？简而言之，就是会返回一个Observab
复制链接

扫一扫