RXJava 2.0操作符学习

1、merge操作符、zip操作符和join操作符
merge是组合多个被观察者一起发送数据，合并后 按发送顺序串行执行。
zip合并后的新数组长度是两个数组中长度小的那个，并且合并的方式可以由我们自己定义。
join合并后的新数组是连个数组的乘积（较少用到）。

2、collect操作符
collect作用是将被观察者Observable发送的数据事件收集到一个数据结构里。
我们在项目中时常会遇到如下需求：一个recycleView展示列表数据，用户下拉刷新的时候请求更多数据，但同时，也可以往上面滑动浏览之前的内容。这个时候之前显示的数据也还是需要缓存下来的，加上最新请求的数据，一起返回给recycleView展示。

Observable<List<ArticleDetailData>> o1 = Observable
                    .fromIterable(new ArrayList<ArticleDetailData>(articleCache.values())) //articleCache便是我们缓存的数据
                    .toSortedList(new Comparator<ArticleDetailData>() {
                        @Override
                        public int compare(ArticleDetailData o1, ArticleDetailData o2) {
                            return SortDataSourceUtil.sortArticleData(o1,o2); //这里比较每一项的时间，做了一个排序
                        }
                    }).toObservable();

Observable<List<ArticleDetailData>> o2 = remoteResource.getArticles(page,forceUpdate,clearCache)
                    .doAfterNext(new Consumer<List<ArticleDetailData>>() {

                        @Override
                        public void accept(List<ArticleDetailData> articleDetailData) throws Exception {
                            refreshArticleCache(clearCache,articleDetailData); //把请求的数据做缓存
                        }
                    });

这个时候只是简单地用merge，把网络请求和本地缓存中两个请求放一起，是不行的，由于本地数据获取很快，这样子只会先返回缓存数据再返回网络请求数据，导致刷新的数据不是我们想要的。这个时候我们需要在merge后面再用collect操作符，把两个数据源收集到一起之后再反馈给界面刷新。

 //获取到的缓存数据加上新请求的数据，合并到一起发送
   return Observable.merge(o1,o2)
          .collect(new Callable<List<ArticleDetailData>>() {  //在这里定义返回的数据类型
                @Override
                public List<ArticleDetailData> call() throws Exception {
                    return new ArrayList<>();
                }
            }, new BiConsumer<List<ArticleDetailData>, List<ArticleDetailData>>() {
                @Override  //collectlist就是容器，datalist就是要收集的数据
                public void accept(List<ArticleDetailData> collectlist, List<ArticleDetailData> datalist) throws Exception {
                    collectlist.addAll(datalist);
                }
            }) .toObservable();

3、Map操作符
Map是RXJava中最简单的变化操作符，它负责把事件中的数据变化成另外一个数据然后再继续发送。

  Observable.create(new ObservableOnSubscribe<Integer>() {

            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onComplete();
            }
        }).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {

                return "index:+"+String.valueOf(integer);  //把数字转换成字符
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.i("dd",s);
            }
        });

4、FlatMap操作符
flatmap是把被观察Observable的一个事件转换成多个发送事件的Observable，但是这些转换的Observable的顺序不能够保证。比如一个网络请求返回的数据中包含了一个集合，我们用到这个集合的时候，可能就需要它这个集合“降维打击”，把它里面的每个数据变成一个Observable来发送。

RetrofitClient
                .getInstance()
                .create(RetrofitService.class)
                .getArticles(page)
                .filter(new Predicate<ArticlesData>() {
                    @Override
                    public boolean test(ArticlesData articlesData) throws Exception {
                        return articlesData.getErrorCode() !=-1;
                    }
                })
                .flatMap(new Function<ArticlesData, ObservableSource<List<ArticleDetailData>>>() {
                    @Override
                    public ObservableSource<List<ArticleDetailData>> apply(ArticlesData articlesData) throws Exception {
                        return Observable.fromIterable(articlesData.getData().getDatas())
                                .toSortedList(new Comparator<ArticleDetailData>() {
                                    @Override
                                    public int compare(ArticleDetailData o1, ArticleDetailData o2) {
                                        return SortDataSourceUtil.sortArticleData(o1,o2);
                                    }
                                }).toObservable();  //这里把data里面的数据集合取出来然后变化成数据集合的发送
                    }
                });

concatMap和flatmap的作用和使用几乎一样，只是concatMap变化后的发送严格按照变化之前的顺序发送。

5、subscribeOn操作符
subscribeOn是用来切换线程使用的操作符，它可以指定产生事件的线程，也可以指定消费事件的线程。RXJava内部给我们提供了四种线程类型，基本上可以满足我们日常的需求：
Schedulers.io()：网络请求或者其他io的操作线程
Schedulers.computation()：计算型线程，比较消耗CPU
Schedulers.newThread()：一个常规的新的子线程
AndroidSchedulers.mainThread()：UI主线程

Disposable disposable = dataRepository.getArticles(page,forceUpdate,clearCache)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeWith(new DisposableObserver<List<ArticleDetailData>>() {
                    @Override
                    public void onNext(List<ArticleDetailData> value) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

        compositeDisposable.add(disposable);

6、filter操作符
filter是一个过滤的操作符，把发射的事件经过一定条件的过滤，才传给下游处理。

filter(new Predicate<ArticlesData>() {
                    @Override
                    public boolean test(ArticlesData articlesData) throws Exception {
                        return articlesData.getErrorCode() !=-1;    //返回等于true的时候，表示可以通过过滤；false就表示此事件会被过滤掉
                    }
                })

7、sample操作符
这个操作符表示每隔多少时间从上游取出一个事件发送给下游处理。