RxJava2操作符（一）

RxJava是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。简单来说就是异步操作工具库。它可以在碰到繁琐、复杂的异步的功能，依然能用保持代码的简洁。
RxJava使用的是观察者模式，Observable(被观察者）与Observer（观察者）通过 subscribe (订阅)实现订阅关系。下面来先写一个简单的例子。来说明他们之间的关系

   /*
     * 简单的例子
     */
    private void SimpleExample() {
        getObservable()
                //上游，被观察者所在线程为io线程
                //多次设置第一次有效
                .subscribeOn(Schedulers.io())
                //下游，观察者所在线程为UI线程
                //可以设置多次，每次都可切换线程
                .observeOn(AndroidSchedulers.mainThread())
                //订阅
                .subscribe(getObserver());
    }

    /**
     * 三种创建观察者的方式
     * @return
     */
    private Observable<String> getObservable() {
        Observable<String> observable=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                     observableEmitter.onNext("cricket");
                     observableEmitter.onNext("football");
                     observableEmitter.onComplete();

            }
        });
        return  observable;
        //第二种通过fromXXX方式
     //   return Observable.fromArray("cricket","football");
        //第三种通过just
       // return Observable.just("cricket", "football");
    }

    /**
     * 观察者
     * @return
     */
    private Observer<String> getObserver() {
        return new Observer<String>() {

            /**
             * 这个最先会被调用
             * Disposable 对象调用dispose()方法可以切断与被观察直接的联系，切断后不再接受到数据
             * @param d
             */
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, " onSubscribe : " + d.isDisposed());
            }


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

            /**
             * onError 和 onComplete()方法互斥，一个事件流里是互斥存在的
             * 不能发送了onError事件又发送onComplete事件
             * @param e
             */

            @Override
            public void onError(Throwable e) {

                Log.d(TAG, " onError : " + e.getMessage());
            }

            @Override
            public void onComplete() {

                Log.d(TAG, " onComplete");
            }
        };
    }

输出结果：

onNext : value : cricket
onNext : value : football
onComplete

map操作符

map操作符可以转换被观察者发射的数据类型，如把Integer转换成String,如下：

 Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {

                        return integer + "发射";
                    }
                }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String value) {
                Log.i(TAG, "value=" + value);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                Log.i(TAG, "onComplete");
            }
        });

输出结果：

 value=1发射 
 value=2发射
 value=3发射
onComplete

flatmap、concatmap 操作符

flatmap和concatmap也数据转换

  /**
     * concatmap flatmap用法 concatmap确保顺序
     * 转换成 Observable<T>
     */
    public void Example04() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .flatMap(new Function<Integer, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(Integer integer) throws Exception {

                        return Observable.just("I am value"+integer+"");

                    }
                }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i(TAG, s);
            }
        });

    }

输出结果：

 I am value1
 I am value2
 I am value3

zip操作符

zip可以把两个被观察者合成一个被观察者对象，如下面的例子

 /**
     * zip操作符的使用
     * 管道少的为准
     */
    public void Example05() {
    //创建一个被观察者
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
               e.onNext(1);
               e.onNext(2);
               e.onNext(3);
               e.onComplete();
            }
        }).subscribeOn(Schedulers.io());
         //创建另一个被观察者
        Observable<String> observable1=Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("A");
                e.onNext("B");
                e.onComplete();
            }
        }).subscribeOn(Schedulers.io());

        Observable.zip(observable, observable1, new BiFunction<Integer, String, String>() {


            @Override
            public String apply(Integer integer, String s) throws Exception {
                Log.i(TAG,"apply"+integer+s);
                return integer+s;
            }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {


                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String value) {
                      Log.i(TAG,value);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                     Log.i(TAG,"onComplete");
                    }
                });

    }

打印的日志

04-04 19:36:46.400 1823-1881/com.liuxin.rxjavademo I/RxjavaUtil: apply1A
04-04 19:36:46.400 1823-1881/com.liuxin.rxjavademo I/RxjavaUtil: apply2B
04-04 19:36:46.428 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: 1A
04-04 19:36:46.429 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: 2B
04-04 19:36:46.429 1823-1823/com.liuxin.rxjavademo I/RxjavaUtil: onComplet

take操作符

使用take操作符，限制发送数据的数量，只会发送被要求数据的数量，如下面有5个数据要发送，但使用take操作符，只发送3个数据

  private void test() {
        getObservable()
                // 被观察者所在线程
                .subscribeOn(Schedulers.io())
                // 观察者线程
                .observeOn(AndroidSchedulers.mainThread())
                //只发送3个
                .take(3)
                .subscribe(getObserver());
    }

    private Observable<Integer> getObservable() {
    //这里有5个数据
        return Observable.just(1, 6, 3, 4, 5);
    }

    private Observer<Integer> getObserver() {
        return new Observer<Integer>() {

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, " onSubscribe : " + d.isDisposed());
            }

            @Override
            public void onNext(Integer value) {

                Log.d(TAG, " onNext value : " + value);
            }

            @Override
            public void onError(Throwable e) {

                Log.d(TAG, " onError : " + e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, " onComplete");
            }
        };
    }

打印日志

 onNext value : 1
onNext value : 6
onNext value : 3
onComplete

这一节就先介绍到这里，下节再介绍其他操作符。