RxJava 之操作符

心已赠人 2022-09-24 10:20 278阅读 0赞

### 什么是RxJava ###

*  **RxJava 就是异步**
 *  **RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。**
 *  **一个响应式的编程框架**

### 什么是RxJava 操作符？ ###

**可以说，操作符是RxJava 最强大的武器**  
操作符一个重要的理念就是，使数据始终处于流上。  
RxJava的操作符是干什么用的呢？简单理解，就是用于进行**转换**、**结合**、**过滤**和**数学运算**等操作的方法。

看看之前的Demo看看我们是如何输出Hello world 的

Observable.just("Hello, world!")  
        .subscribe(new Action1<String>() {  
            @Override  
            public void call(String s) {  
                  System.out.println(s);  
            }  
        });

好了，现在如果要求你将**输入内容按照大写输出**，你会怎么改呢？首先看看RxJava的做法：

Observable.just("hello world")
                    .map(new Func1<String, String>() {
    
                        @Override
                        public String call(String s) {
                            return s.toUpperCase();
                        }
                    })
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(String s) {
                            Log.e(MainActivity.class.getSimpleName(), "onNext--->" + s);
                            Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
                        }
                    });

你也许会不服，觉得在Subscribe的call里面修改不一样可以吗？

好，再来，如果要求你将输入内容的截取部分内容输出，同时又不需要转换成大写了，我们用RxJava实现：

Observable.just("hello world")
    //                .map(new Func1<String, String>() {
        
    //
    //                    @Override
    //                    public String call(String s) {
        
    //                        return s.toUpperCase();
    //                    }
    //                })
                    .map(new Func1<String, String>() {
    
                        @Override
                        public String call(String s) {
                            return s.substring(6);
                        }
                    })
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(String s) {
                            Log.e(MainActivity.class.getSimpleName(), "onNext--->" + s);
                            Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
                        }
                    });

#### map ####

上面用到的map()操作符就是用于变换Observable对象的，map操作符返回一个Observable对象，这样就可以实现链式调用。

你可能稍微有点动心了，需求的改变，不会导致 Observable 和 Subscribe 实现方式的更改，这应该是我们最希望的模式吧。

> 需修变更，最好的不去更新之前测试过的代码。

这里的例子很简单，我们就算去修改Subscribe的实现，主要是call方法实现，你也不会觉得有多么困难，但是实际开发中可不是这么简单。

#### create & just ####

create 也是操作符，用于创建一个包含 onNext()、onComplete和onError() 事件的Observable对象。  
just 就是用来创建只发出一个事件就结束的Observable对象

### RxJava操作符初探 ###

#### from ####

Observable.from()方法，它接收一个集合作为输入，然后每次输出一个元素给subscriber。当有多个输入，那么就类似队列，一个一个来的时候，需要通过循环输出，而from刚好可以实现这个功能

ArrayList<String> datas = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                datas.add("item_" + i);
            }
    
    Observable.from(datas)
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(String s) {
                            Log.e(MainActivity.class.getSimpleName(), "call---->" + s);
                        }
                    });

是不是很神奇，没有for循环，居然完成了list的遍历输出。

这里我们的宗旨还是不要去改变Subscribe的实现。

#### flatMap ####

Observable.flatMap()接收一个Observable的输出作为输入，同时输出另外一个Observable。

ArrayList<String> datas = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                datas.add("item_" + i);
            }
    
           Observable.just(datas)
                    .flatMap(new Func1<ArrayList<String>, Observable<String>>() {
                        @Override
                        public Observable<String> call(ArrayList<String> strings) {
                            return Observable.from(strings);
                        }
                    })
                    .map(new Func1<String, Integer>() {
                        @Override
                        public Integer call(String s) {
                            return s.hashCode();
                        }
                    })
                    .subscribe(new Action1<Integer>() {
                        @Override
                        public void call(Integer Integer) {
                            Log.e(MainActivity.class.getSimpleName(), "call---->" + Integer);
                        }
                    });

这里我们从**just**操作符得到Observable，经过**flatMap**再次得到一个Observable，并且最后通过**map**操作符输出了我们列表中每一个数据的hash值。

注意在这段代码里，我们的Observable和Subscribe并没有任何对数据的操作 ，通过RxJava强大的操作符我们就完成了从  
List—->String—->Integer 的**数据类型转换**输出。

#### filter ####

这个单词很好理解，**过滤**，这个操作符的意义也就是过滤。

Observable.from(datas)
                    .filter(new Func1<String, Boolean>() {
                        @Override
                        public Boolean call(String s) {
                            return !s.equals("item_5");
                        }
                    })
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(String s) {
                            Log.e(MainActivity.class.getSimpleName(), "call---->" + s);
                        }
                    });

日志输出

![filter][]

这里我们可以看到，item\_5 的内容已经被过滤掉了。

#### take ####

take()输出最多指定数量的结果。

这个应该很好理解了，就是指定了最多输出的项数，相当于是限定了for循环的次数。

#### doOnNext ####

doOnNext()允许我们在每次输出一个元素之前做一些额外的事情。

Observable.from(datas)
                    .filter(new Func1<String, Boolean>() {
                        @Override
                        public Boolean call(String s) {
                            return !s.equals("item_5");
                        }
                    })
                    .take(5)
                    .doOnNext(new Action1<String>() {
                        @Override
                        public void call(String s) {
                            s=s.substring(0,3).toUpperCase();
                            Log.e(MainActivity.class.getSimpleName(), "call---->" + s);
                        }
                    })
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(String s) {
                            Log.e(MainActivity.class.getSimpleName(), "call---->" + s);
                        }
                    });

这里我们只输出了列表里的前5项，并且在每一个项输出之前，截取其前3个字符，并转换为大写输出。

#### Range ####

range(n,m) Range操作符根据出入的初始值n和数目m发射一系列大于等于n的m个值

Observable
                    .range(12, 10)
                    .subscribe(new Action1<Integer>() {
                        @Override
                        public void call(Integer integer) {
                            Log.e(MainActivity.class.getSimpleName(), "the integer is " + integer);
                        }
                    });

输出如下：

![range][]

这个操作符很好理解 。

> 当然了，这里的这些处理是很简单的，但在实际业务逻辑中，这样的流式操作数据是很有意义，且很方便的。至少，代码在后期维护起来会方便许多。

RxJava包含了大量的操作符，真的非常多。而且从上面列举的这几个操作符可以看出，各种操作符可以无限制的组合使用，所以说，操作符是RxJava最为强大的武器之一，更有意思的是，操作符是可以自定义的，这样的套路，想想都觉得刺激，但这些都是需要花费大量精力去学习的。

感兴趣的同学 可以看看[RxMarbles][]，这里通过生动的图片对各种不同种类的操作符进行了描述。

其实，上面所有操作符的功能，在Java 语言中，我们用for,if，else等许多行**谜之缩进**的语句实现是完全没有问题的，但是那样的代码，就算是写代码的人，后期维护起来也是不容易的。

而我们使用RxJava的操作符的组合排列，秉承着**使数据始终处于流上**的观念，代码被分解成了一系列的片段，这样最起码维护和更新的时候会方便许多。

好了，关于操作符的内容就到这里。

--------------------

[filter]: /images/20220719/074cfbd8997144af9d74085dfbfb0b10.png
[range]: /images/20220719/c4871e68f221416ea18081aca70159fd.png
[RxMarbles]: http://rxmarbles.com/