RxJava 之 操作符

什么是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);                    }                });

日志输出

这里我们可以看到，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);                    }                });

输出如下：

这个操作符很好理解 。

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

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

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

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

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

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

---