Android Rxjava使用方法

RxJava

是什么：异步
好处：

• 代码简洁可读性强
• 可随意的切换线程

最基本的使用方法
首先要在gradle文件中加入.jar文件
compile ‘io.reactivex:rxjava:1.2.7’
compile ‘io.reactivex:rxandroid:1.0.1’
要满足三个条件，（1）创建Observer观察者 (2)创建Observable被观察者 （3）Subscribe完成订阅。
下面我们来写一个最基本的功能。代码如下：

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("Word");
                subscriber.onCompleted();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted: enter");
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext: s = " + s);
            }
        });

其中Observer可以这样写：

Action1<String> onNext = new Action1<String>() {
            @Override
            public void call(String s) {
                Log.d(TAG, "call: s = " + s);
            }
        };
        Action1<Throwable> onError = new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.d(TAG, "throwable  :");
            }
        };
        Action0 onCompleted = new Action0() {

            @Override
            public void call() {
                Log.d(TAG, "onCompleted: enter");
            }
        };


        Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("Word");
                subscriber.onCompleted();
            }
        }).subscribe(onNext,onError,onCompleted);

创建Observable的方法常用的为：

//这里的just(T...)将传如的参数依次发送出来;
        Observable observable = Observable.just("Hello","Word","My","God");

        String [] words = {"Hello","Word","My","God"};
        Observable observable2 = Observable.from(words);

        // just(T...) 与 from(T[])方法都是如下意思;
        // onNext("Hello");
        // onNext("Word");
        // onNext("My");
        // onNext("God");

上面的介绍中我们Rxjava默认事件的发生和消费都在同一个线程中，现在还只是一个同步的观察者模式。

Rxjava的线程控制；

因为Rxjava 默认情况下，事件发生与消费都在同一个线程中；那么这样的话根本就没起到异步的作用；
所以下面我们来介绍Rxjava的核心–线程控制 Scheduler（调度）
Rxjavay已经内置了几个Scheduler 如下：
Schedulers.immediate(): 直接在当前线程运行,这是默认的 Scheduler。
Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
另外， Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
以上几种中最常用的是Schedulers.io()与AndroidSchedulers.mainThread()

有了以上这些线程就可以对事件的线程进行操作了。操作线程的方法有如下两种：

Observable.just("Hello", "Word", "My", "God")
                //指定 subscribe() 发生在IO 线程;
                .subscribeOn(Schedulers.io())
                // 指定 Subscriber 的回调发生在主线程;
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.d(TAG, "call: s = " + s);
                    }
                });

Rxjava最牛逼的地方 －－变换；

所谓变化就是将事件序列中的对象或整个序列进行加工处理，转换成不同事件或事件序列。
API map() 和 flatMap()
map() 的转换是一对一的转换，
例子；

        //输入string类型;
        Observable.just("1234", "4567", "3345", "3567")
                //转化成Integer类型;
                .map(new Func1<String, Integer>() {
                    @Override
                    public Integer call(String s) {
                        return Integer.valueOf(s);
                    }

                }).subscribe(new Action1<Integer>() {
            //参数为Integer类型;
            @Override
            public void call(Integer integer) {
                Log.d(TAG, "call: integer = " + integer);
            }
        });

flatMap() 的作用与map()有点相同，但是flatMap()是一对多的转换，他返回的是一个Observable对象，并且这个对象并不直接发送到Subscriber的方法回调中，而是等待激活。

 Observable.just("1234", "4567", "3345", "3567")
                //他返回的是一个Observable对象;
                .flatMap(new Func1<String, Observable<Integer>>() {
                    @Override
                    public Observable<Integer> call(String s) {
                        return Observable.just(Integer.valueOf(s));
                    }
                })
                //为过滤操作符,只有满足条件的才进入下一步;
                .filter(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer != 0;
                    }
                })
                //事物处理在io线程中完成;
                .subscribeOn(Schedulers.io())
                //结果在主线程中展现;
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        mText.setText("" + integer);
                    }
                });