学习RxJava

学习RxJava，就一定得知道这三个词语：Observer(观察者) ， Observable(被观察者)， subscribe(订阅)。 这个，怎么说呢，我认为它的流程就跟回调差不多。那有啥好学的呢？就是它的异步操作（可以随心所欲的切换线程），突然就觉得它高大上啦~~~~
第一步：创建一个观察者

第一种：
Observer observer = new Observer() {
            @Override
            public void onCompleted() {
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onNext(Object o) {
            }
        };
第二种：
Subscriber subscriber = new Subscriber() {
            @Override
            public void onCompleted() {
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onNext(Object o) {
                  Log.i("打印结果",o+"-----------");
            }
        };

第二步创建被观察者：

Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("hello");
                subscriber.onNext("world");
                subscriber.onCompleted();
            }
        });

第三部：

observable.subscribe(subscriber);

流程就是这样，在被观察者调用subscribe()方法的时候，就会调用call方法，示例代码的call方法里面是走了两次onNext方法，一次onCompleted方法。

可能觉得挺麻烦的，确实是，这就需要对观察者的简单包装：

Action0 action0 = new Action0() {
        @Override
        public void call() {

        }
    };
Action1 actionNext = new Action1<Object>() {
        @Override
        public void call(Object o) {

        }
    };
Action1 actionError = new Action1<Throwable>(){
        @Override
        public void call(Throwable throwable) {

        }
    };

这是啥？我们发现观察者里面的三个方法，一个是onNext,一个是onError,一个是onCompleted.其中，onCompleted是没有参数的，而onNext和onError是有参数的，我们就可以用Action0 （无参数）和Action1（有参数）来代替。

Func0 func0 = new Func0<Object>(){
        @Override
        public Object call() {
            return null;
        }
    };
Func1 func1 = new Func1<Object, Object>() {
        @Override
        public Object call(Object o) {
            return null;
        }
    };

这两个方法，与上面的action不同的就是有返回。

我们订阅的时候，很多的时候需要对数据进行转化，这个时候，就出现了map, flatMap这两个方法。我们可以在map里面对数据进行处理，然后再返回。

Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {

            }
        })
        .map(new Func1<Object, Object>() {
            @Override
            public Object call(Object o) {
                return null;
            }
        })
        .subscribe(new Action1<Object>() {
            @Override
            public void call(Object o) {

            }
        });

异步操作:
异步操作两个重点的方法：subscribeOn(),以及observeOn().
方法里面的参数：
AndroidSchedulers.mainThread()表示UI线程，
Schedulers.io()表示io线程池里面取一个线程，
Schedulers.newThread()表示新建一个线程。

Observable.from(infos)  //ui线程，由subscribleOn指定。
                .subscribeOn(AndroidSchedulers.mainThread()) //定义被观察者的线程
                .observeOn(Schedulers.io())
                .map(func1) //io 线程
                .observeOn(Schedulers.newThread())
                .map(func2) //新的线程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(actionNext); //ui线程

之所以，可以随心所欲的异步切换，就是一心observeOn()方法的多次调用。