RxJava的车间操作工人-操作符

如果你对RxJava1.x还不是了解，可以参考下面文章。

1. RxJava使用介绍 【视频教程】
2. RxJava操作符
  • Creating Observables(Observable的创建操作符) 【视频教程】
  • Transforming Observables(Observable的转换操作符) 【视频教程】
  • Filtering Observables(Observable的过滤操作符) 【视频教程】
  • Combining Observables(Observable的组合操作符) 【视频教程】
  • Error Handling Operators(Observable的错误处理操作符) 【视频教程】
  • Observable Utility Operators(Observable的辅助性操作符) 【视频教程】
  • Conditional and Boolean Operators(Observable的条件和布尔操作符) 【视频教程】
  • Mathematical and Aggregate Operators(Observable数学运算及聚合操作符) 【视频教程】
  • 其他如observable.toList()、observable.connect()、observable.publish()等等； 【视频教程】
3. RxJava Observer与Subcriber的关系 【视频教程】
4. RxJava线程控制（Scheduler） 【视频教程】
5. RxJava 并发之数据流发射太快如何办（背压（Backpressure）） 【视频教程】

---

在RxJava中，如果把整个事件流看作是工厂的流水线，Observable就是原料，Observer就是我们的产品经理，这个产品是怎么交到我们产品经理手上的呢？ 中间很重要的就是工人，也就是操作符。它负责在Observable发出的事件和Observable的响应之间做一些处理。

首先我们来看一段Java代码：

static List<Student> studentList = new ArrayList<Student>(){        {            add(new Student("Stay", 28));            add(new Student("谷歌小弟", 23));            add(new Student("Star", 25));        }    };List<Student> list = new ArrayList<Student>();        new Thread(new Runnable(){            @Override public void run(){                synchronized (studentList) {                    for(Student student : studentList) {                        if(student.age > 23){                            list.add(student);                        }                    }                }                runOnUiThread(new Runnable() {                      @Override                       public void run() {                           //UI显示过滤后的数据                           displayUI(list);                       }                   });            }        }).start();

此段代码实现的是过滤数据，也就是统计年龄大于23的学生，并将过滤数据显示在UI上。

使用RxJava来实现（体验一下RxJava的链式结构）：

Observable.from(studentList)    //from可以理解为创建一个循环        .filter(new Func1<Student, Boolean>() {//filter代表根据规则过滤            @Override            public Boolean call(Student student) {                return student.age > 23; //过滤年龄大于23的学生            }        }).subscribeOn(Schedulers.newThread()) //任务在新线程里运行        .toList()        .subscribeOn(Schedulers.io())        .observeOn(AndroidSchedulers.mainThread())        .subscribe(new Action1<List<Student>>() {            @Override            public void call(List<Student> list) {                //UI显示过滤后的数据                displayUI(list);            }        });

可以看到，代码减少了，而且逻辑也很清晰。

下面我们再看个复杂点的场景：找出SD卡所有的.png格式的文件。

String basePath = Environment.getExternalStorageDirectory().getPath();        File rootFile = new File(basePath);        Observable.just(rootFile)                .flatMap(new Func1<File, Observable<File>>() {                    @Override                    public Observable<File> call(File file) {//遍历文件夹                        return listFiles(file);                    }                })                .filter(new Func1<File, Boolean>() {//过滤图片，二级文件夹中的图片无法找出                    @Override                    public Boolean call(File file) {                        return file.getName().endsWith(".png");                    }                })                .map(new Func1<File, String>() {                    @Override                    public String call(File file) {                        return file.getPath();                    }                })                .toList()                .subscribeOn(Schedulers.io())                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Subscriber<List<String>>() {                    @Override                    public void onCompleted() {                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(List<String> list) {//返回png格式图片列表                        //do something                    }                });

其中，listFiles方法如下：

/**     * 递归查询目录中的文件     * @param f     * @return     */    public static Observable<File> listFiles(final File f){        if(f.isDirectory()){            return Observable.from(f.listFiles()).flatMap(new Func1<File, Observable<File>>() {                @Override                public Observable<File> call(File file) {                    /**如果是文件夹就递归**/                    return listFiles(file);                }            });        } else {            /**filter操作符过滤,是文件就通知观察者**/            return Observable.just(f).filter(new Func1<File, Boolean>() {                @Override                public Boolean call(File file) {                    return f.exists() && f.canRead() ;                }            });        }    }

从上面这段代码我们可以看到：虽然代码量看起来变复杂了，但是RxJava的实现是一条链式调用，没有任何的嵌套；整个实现逻辑看起来非常简洁清晰，这对我们的编程实现和后期维护是有巨大帮助的。特别是对于那些回调嵌套的场景。

有没有心动，喜欢上RxJava了呢？

将非Rx方法转换成Rx方法

/** * 模拟从数据库获取课程列表 * @return */private static  List<String> getCoursesFromDatabase() {    List<String> courseList = new ArrayList<>();    courseList.add("美术");    courseList.add("体育");    courseList.add("音乐");    return courseList;}

在RxJava中，just和from操作符可以把一个对象转换成Observable，上面的方法使用just改写：

private static Observable<List<String>> getAllCourses() {     return Observable.just(getCoursesFromDatabase());}

不过这样改写会有个问题，只要调用getAllCourses方法就会运行getCoursesFromDatabase方法，那么就不能通过指定Schedules的方式实现异步查询了。

所以如果某个方法经常会被异步调用，我们往往会使用create来改写：

private static Observable<List<String>> getAllCourses() {        return Observable.create(new OnSubscribe<List<String>>() {            @Override            public void call(Subscriber<? super List<String>> subscriber) {                 List<String> courseList = getCoursesFromDatabase();                subscriber.onNext(courseList);                subscriber.onCompleted();            }        });    }

在使用Create操作符时，getCoursesFromDatabase方法是写在OnSubscribe接口的call方法里。调用getAllCourses方法，getCoursesFromDatabase并不会马上运行。

getAllCourses(db)    .subscribeOn(Schedulers.io())    .observeOn(AndroidSchedulers.mainThread())    .subscribe(new Subscriber<String>(){...});

注意：
因为just()，from()这类创建Observable的操作符在创建之初，就已经存储了对象的值，而不是在被订阅的时候才创建。所以在我们订阅之前，getCoursesFromDatabase()方法就已经在开始执行了，这样就不能达到我们想要的效果。

丰富的操作符

RxJava中的操作符可以让你对数据流做任何操作。

将一系列的操作符链接起来就可以完成复杂的逻辑。代码被分解成一系列可以组合的片段。这就是响应式函数编程的魅力。用的越多，就会越多的改变你的编程思维。

另外，RxJava也使我们处理数据的方式变得更简单。在最后一个例子里，我们调用了两个API，对API返回的数据进行了处理，然后保存到磁盘。 但是我们的Subscriber并不知道这些，它只是认为自己在接收一个Observable<String>对象。良好的封装性也带来了编 码的便利！

RxJava的强大性就来自于它所定义的操作符。

RxJava包含了大量的操作符。操作符的数量是有点吓人，但是很值得你去挨个看一下，这样你可以知道有哪些操作符可以使用。弄懂这些操作符可能会花一些时间，但是一旦弄懂了，你就完全掌握了RxJava的威力。

你甚至可以编写自定义的操作符！这篇blog不打算讨论自定义操作符，如果你想的话，请自行Google吧。

目前为止，我们已经接触了filter、just、create三个操作符，RxJava中还有更多的操作符，那么我们如何使用其他的操作符来改进我们的代码呢？不要着急，后面会分类学习RxJava的操作符。