关于RxJava，Scheduler 调度器，map事件转换的过程与原理

  在这里首先简单的描述一下本文的具体内容；

1，将RxJava的多种使用方法，通过简单案例的形式展示给大家，并且带有备注，

2，之后，在RxJava基本使用方法的基础上，增添以下Scheduler 调度器的使用，来进行线程等的切换，

3，如何将RxJava内部的一些事件进行转换，如何单个转换，如何整个转换；

可能过程案例比较多，各取所需吧》》》》

1,（a）第一种写法（分步的，如果有喜欢连用的可连用）：

/** * 演示RxJava的介绍以及基本使用 * * 1.RxJava是什么? *    RxJava本质就是一个实现异步操作的库  异步 * * 2.RxJava优点  简洁(随着程序的逻辑变得复杂 可以将复杂的逻辑代码串成一条线) * * 3.原理 RxJava异步实现 拓展的观察者模式 * *  观察者模式:A对象(观察者)对B(被观察者)对象的某种变化比较敏感  需要在B对象变化的瞬间 *  作出反应 程序中的观察者模式 采用注册或者订阅方式 告诉被观察者当他变化是通知观察者 * *  android应用中的观察者案例 view视图绑定单击事件 *  view被观察者－－－onClickListener单击事件的监听器 观察者 *    注册/订阅 setOnClickListener() *  当单击view视图时 通知onClickListener单击事件的监听器观察者对象作出响应(回调onClick方法) * * RxJava中观察者模式 * RxJava中四个基本概念 Observable(被观察者) Observer(观察者) *  Subscribe(订阅/注册) *  Observable(被观察者) Observer(观察者)通过Subscriber()方法实现订阅关系 *  Observable需要时发出事件通知Observer * */public class MainActivity extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        //1.创建Observer观察者对象 他主要决定事件触发时有怎么样的行为        Observer<String> observer=new Observer<String>() {            /**             * 事件队列操作完毕时回调的寒肃             * rxjava中事件处理时不仅可以单独处理还可以看作事件队列             *             * 作为事件结束的标志             */            @Override            public void onCompleted() {                Log.i("tag","------onCompleted------");            }            /**             * 事件处理过程中出现异常的时候回调             * onError()被触发 整个的事件的处理中止             * 注意:onCompleted()和onError()互斥  正常的事件处理过程中只会调用其中一个函数             */            @Override            public void onError(Throwable e) {                e.printStackTrace();            }            /**             * 类似与view中 OnClickListener中的onClick方法             *  主要对被观察者触发的事件处理的方法             */            @Override            public void onNext(String s) {                Log.i("tag","-------onNext-----"+s);            }        };        //2.创建被观察者对象 他决定什么时候触发事件以及触发怎么样的事件        /*        Observable.create() RxJava中创建事件序列的方法        create()方法中需要传入OnSubscribe对象 OnSubscribe存储到Observable对象中(计划表)        当Observable被订阅时 OnSubscribe接口中的call()会被回调 事件的序列才会依次执行触发         */        Observable observable=Observable.create(new Observable.OnSubscribe<String>() {            @Override            public void call(Subscriber<? super String> subscriber) {                subscriber.onNext("Hello");                subscriber.onNext("hi");                subscriber.onNext("how are you");                subscriber.onCompleted();            }        });        //3. 订阅 注册  view.setOnClicklistener(onClickListener)        observable.subscribe(observer);    }}

1（b）(第二种写法)

/** * 演示RxJava中的变换写法 */public class MainActivity02 extends AppCompatActivity {    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        /**         * RxJava中有一个具体实现Observer抽象类的类 Subscriber         * Subscriber是Observer观察者类的具体子类 对Observer观察者进行了拓展         * 如果只是使用基本功能 Subscriber、Observer基本一样         * 区别：         * 1.Subscriber类中增加了onStart()方法         * 2.unSubscribe()取消订阅 当该方法被调用后 Subscriber将不再接收事件         */        Subscriber<String> subscriber=new Subscriber<String>() {            @Override            public void onCompleted() {                Log.i("tag","------onCompleted------");            }            @Override            public void onError(Throwable e) {                 e.printStackTrace();            }            @Override            public void onNext(String s) {                Log.i("tag","-------onNext-----"+s);            }            /**             * Subscriber中添加的方法  表示在事件发送之前被调用 准备工作  数据清零重置操作             */            @Override            public void onStart() {                super.onStart();            }        };        //2.创建被观察者对象 他决定什么时候触发事件以及触发怎么样的事件//        Observable observable=Observable.create(new Observable.OnSubscribe<String>() {//            @Override//            public void call(Subscriber<? super String> subscriber) {//                subscriber.onNext("Hello");//                subscriber.onNext("hi");//                subscriber.onNext("how are you");//                subscriber.onCompleted();//            }//        });        //just() 将传入的参数作为onNext()方法的参数进行使用//        Observable observable=Observable.just("Hello","Hi","how are you");        String[] array={"Hello","Hi","how are you"};        Observable observable=Observable.from(array);        //3. 订阅 注册  view.setOnClicklistener(onClickListener)//        observable.subscribe(observer);        observable.subscribe(subscriber);    }}1（c）第三种写法，使用的action的封装方法：这里的call其实就是，next(),complete()等的拆分，都
被叫做call,大家不要混乱
<pre name="code" class="java">/** * 演示RXJava中Action1 Action0对Observer封装的写法 */public class ActionActivity extends AppCompatActivity{    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        /**         * Action0是RxJava中的接口 具有一个方法call()  该方法无参数 无返回值         * Observer观察者类中onCompleted()也是无参数无返回值  Action0当作         * 一个包装对象  将onCompleted()的内容打包作为参数进行提供给subscribe()         * 进行使用  不完整定义的回调         */        Action0 completed=new Action0() {            @Override            public void call() {                Log.i("tag","--------onComplted----");            }        };        /**         *  Action1 也是一个接口 具有一个call(T t) 该方法具有一个参数无返回值         *  对onNext()方法的封装作为不完整定义的回调         */        Action1<String> nextAction=new Action1<String>() {            @Override            public void call(String s) {                Log.i("tag","-------onNext----"+s);            }        };        Action1<Throwable> errorAction=new Action1<Throwable>() {            @Override            public void call(Throwable throwable) {                throwable.printStackTrace();            }        };        Observable observable=Observable.just("Hello","Hi");        observable.subscribe(nextAction,errorAction,completed);    }}/* Observer<String> observer=new Observer<String>() {            @Override            public void onCompleted() {}            @Override            public void onError(Throwable e) {}            @Override            public void onNext(String s) {}        } */

三种写法都写了，下面我通过整体的写法展示给大家，然后将其中加上一些调度和事件转换的使用

<pre name="code" class="java">/** * RxJava出现就是为了实现异步操作 后台处理[工作线程处理耗时操作] 前台调用[UI线程调用显示] * Scheduler 调度器  线程的控制器   RxJava中通过该对象指定每一段代码运行在哪个线程中 *  RxJava中内置的调度器 *  Schedulers.immediate()  默认scheduler 直接在当前线程中执行 *  Schedulers.newThread() 表示启动新的线程 并且代码在新线程中执行操作 *  Schedulers.io() io操作线程（读写文件 读写数据库 网络信息交互等） *    io()与newThread()行为模式类似  区别:io()内部无数量上限的线程池 *    比newThread()更高效 *  Schedulers.computation() 复杂的计算使用调度器 * * RxAndroid中专门的AndroidSchedulers.mainThread()将操作放到android的主线程/ui线程中执行 */public class SchedulerActivity extends AppCompatActivity{    private ImageView iv;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        iv= (ImageView) findViewById(R.id.iv_show);        Observable.create(new Observable.OnSubscribe<Drawable>() {            @Override            public void call(Subscriber<? super Drawable> subscriber) {                Drawable drawable=getResources().getDrawable(R.mipmap.cat);                subscriber.onNext(drawable);                subscriber.onCompleted();            }        })      /**         subscribeOn()指定事件发生的线程 就是Observable.OnSubscribe被调用时所处的线程         表示Observable被观察者对象中的call方法执行的线程                */                .subscribeOn(Schedulers.io())                /**                 * observeOn() 表示Observer观察者运行的线程 事件的消费线程                 */                .observeOn(AndroidSchedulers.mainThread())                .subscribe(new Observer<Drawable>() {            @Override            public void onCompleted() {            }            @Override            public void onError(Throwable e) {            }            @Override            public void onNext(Drawable drawable) {                iv.setImageDrawable(drawable);            }        });    }}

事件转换：案例一：

<pre name="code" class="java">/** * 演示 RxJava中对事件的转换 * 事件转换:将事件序列中对象或者是整个事件序列进行加工处理 转换成不同的事件序列 */public class MapActivity extends AppCompatActivity {    private ImageView imageView;    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        imageView = (ImageView) findViewById(R.id.iv_show);        //图片的路径(字符串)--bitmap图片的对象进行展示        final String filePath = Environment.getExternalStorageDirectory().getAbsolutePath() +                File.separator + "dog.jpg";        Observable.just(filePath)                /**                 * map()对事件转换的方法  参数Func1                 * Func1也是RxJava中的接口 与Action1类似 用于包装具有一个参数的函数                 *                 * Func1和Action1的区别                 * Func1 包装具有返回值的方法                 * Action1 包装无返回值的方法                 *                 * Func1<需要转换的事件的类型,转换后的结果类型>                 *   Func1底层对create()方法的封装 将String字符串转换成bitmap封装到                 *   Observable被观察者对象中                 */                .map(new Func1<String, Bitmap>() {                    @Override                    public Bitmap call(String s) {                        return BitmapFactory.decodeFile(s);                    }                })                .subscribe(new Action1<Bitmap>() {                    @Override                    public void call(Bitmap bitmap) {                        imageView.setImageBitmap(bitmap);                    }                });    }}

案例二：

<pre name="code" class="java">/** * 演示RxJava中对整个事件序列的转换 */public class FlatMapActivity extends AppCompatActivity{    @Override    protected void onCreate(@Nullable Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);       //2.需求:Student类中加入需要学习的课程名称 区别:每个学生只有一个名字 但是可以学习多门课程        List<Course> list01=new ArrayList<>();        list01.add(new Course(1,"语文"));        list01.add(new Course(2,"数学"));        final Student stu01=new Student(1,"张三",list01);        List<Course> list02=new ArrayList<>();        list02.add(new Course(1,"Android"));        list02.add(new Course(2,"Java"));        Student stu02=new Student(2,"李斯",list02);        Student[] stus={stu01,stu02};        /**         * flatMap()和map()共同点 都是对传入的参数转换返回另一个对象         * 不同点:flatMap()转换后返回是Observable对象         */        Observable.from(stus)                .flatMap(new Func1<Student, Observable<Course>>() {                    @Override                    public Observable<Course> call(Student student) {                        return Observable.from(student.getCourses());                    }                })                .subscribe(new Observer<Course>() {                    @Override                    public void onCompleted() {                    }                    @Override                    public void onError(Throwable e) {                    }                    @Override                    public void onNext(Course course) {                        Log.i("tag","----course-----"+course.getCourseName());                    }                });    }}