在GitHub里面，RxJava的官方定义是： "a library for composing asynchronous and event-based programs using observable sequences for the Java VM" 这里大概翻译是：一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。

   最近刚好碰到一个用了mvp+RxAndroid+RxJava的框架的项目，刚刚接触对lambda简直一脸懵逼。还因为只能跑在1.8版本的jdk，表示默默从1.7版本升级了~

常用标识符介绍：

（一）just与from
   使用场景：在有时候，我们发布的事件是多件，但是订阅者只需要一个即可，那么我们要写多个Observable吗？答案是：不需要。这里RxJava提供了两个操作符，分别为：just与from。两者实现功能是等价的，都可以同时初始化多个Observable，并且发布到同一个订阅者。具体实现方式如下：

    Observable.just("1", "2", "3").subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        });
 
        String[] datas = {"4", "5", "6"};//等价于 jsut(...)
        Observable.from(datas).subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i(TAG, s);
            }
        });

（二）强大的变换 map
   使用场景，当我们发布一个事件的时候，例如发布的时候自带了一个网络图片链接，我们不希望在订阅者处理事件的时候，还要跑将url转化为Bitmap的逻辑（因为这样一定程度会消耗在主线程的事件，造成界面卡顿），因此我们希望有个机制可以帮我们将url转化成Bitmap，这就是操作符map的操作功能，具体实现如下：

  String imgUrl = "";
        Observable.just(imgUrl)
                .map(new Func1<String, Bitmap>() {
                    @Override
                    public Bitmap call(String s) {
                       Bitmap bitmap = ToolUtils.url2Bitmap(s);
                        return bitmap ;
                    }
                })
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) {
                        imagview.setImageBitmap(bitmap);
                    }
                });

(3)强大的变换flatMap
   使用场景：在上面案例中Map只能做一对一的转化。假如有一个场景，在一个学生对象中，拥有属性课程，并且一个学生可以拥有多个课程信息。这里如果用map将学生转化为课程信息，明显这种一对多的场景map实用不了，因此我们也希望有个新的机制可以对一对多场景进行转化，具体实现如下：

 List<Student> datas = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            String cuoursName = Integer.toString(i) + "同学课程";
            String[] cours = {cuoursName, cuoursName, cuoursName, cuoursName, cuoursName, cuoursName, cuoursName, cuoursName, cuoursName};
            Student student = new Student(Integer.toString(i) + "同学", cours);
            datas.add(student);
        }
        Subscriber<String> mSubscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {}
            @Override
            public void onError(Throwable e) {}
            @Override
            public void onNext(String s) {
                Log.i(TAG, s);
            }
        };
 
        Observable.from(datas).flatMap(new Func1<Student, Observable<String>>() {
            @Override
            public Observable<String> call(Student student) {
                Log.i(TAG, student.getName());
                return Observable.from(student.getCours());
            }
        }).subscribe(mSubscriber);

   读者阅读到这里，也许会觉得flatMap比较难理解，笔者第一次接触的时候也相对觉得的确不好理解，如果你按照递归的方式去思考这个操作符，flatMap与map唯一的去吧，就是回调call的时候还是返回了一个发布者Observable，因此在订阅者接收的时候，其实是多次性被触发了。

最后

   技术迭代非常快，除了天天忙碌的工作，也要挤点时间积累积累。温习旧知识，学习新技术！共勉！

傻小孩b
共勉，写给在成长路上奋斗的你