RxJava—操作符（过滤、合并、转换）

RxJava—过滤、合并、转换

本来RxJava基础部分是打算在上个月完成的，项目实在太赶，越发觉得坚持做一件事情，并且要做好这件事情并不是容易的事。这一章将讲述RxJava消息序列的过滤、合并、转换，也就是RxJava中非常重要的一部分——操作符。
提供demo下载：传送门

一、RxJava—过滤（filter）

首先我们准备一个字符串列表，里面随意写入一些字符串，以备后用：

List list = new ArrayList<>();
        list.add("pdm");
        list.add("xiaohong");
        list.add("pdm");
        list.add("pdm");
        list.add("xiaoming");
        list.add("xiaohua");

1、filter

这里以数据库查询为例，假设你已经获取了数据库里所需数据集合，数据内容即为上述的list，现在需要将带”xiao”的项找出来，我们就可以用到Observable的filter方法。

subscription = Observable.from(list).filter(new Func1<String, Boolean>() {
                    @Override
                    public Boolean call(String s) {
                        return s.contains("xiao");
                    }
                }).subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        final String info = s;
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                if (adapter != null){
                                    adapter.add(info);
                                }
                            }
                        });
                    }
                });
                subscription.unsubscribe();

2、take

如果你需要获取集合中的前几项数据，可以用Observable的take方法。最后几项则用takeLast方法：

subscription = Observable.from(list).take(3).subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        final String info = s;
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                if (adapter != null){
                                    adapter.add(info);
                                }
                            }
                        });
                    }
                });

3、Distinct

如果你需要过滤掉集合中的重复项，可以用Observable的distinct方法。

 subscription = Observable.from(list).distinct().subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        final String info = s;
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                if (adapter != null){
                                    adapter.add(info);
                                }
                            }
                        });
                    }
                });
                subscription.unsubscribe();

4、DistinctUtilChanged

如果你需要过滤集合中的相邻重复项，可以用Observable的distinctUtilChanged方法。

//过滤相邻的重复项
subscription = Observable.from(list).distinctUntilChanged().subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        final String info = s;
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                if (adapter != null){
                                    adapter.add(info);
                                }
                            }
                        });
                    }
                });
                subscription.unsubscribe();

5、Skip

如果你需要过滤掉前面几项或者后面几项，可以使用Observable的skip和skipLast方法。

//这里过滤掉前面两个数
subscription = Observable.from(list).skip(2).subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        adapter.add(s);
                    }
                });
                subscription.unsubscribe();

5、ElementAt

如何你需要发送指定的某一条数据，可以使用Observable的elementAt方法。

subscription = Observable.from(list).elementAt(4).subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        adapter.add(s);
                    }
                });
                subscription.unsubscribe();

这里举例的是几种常用的过滤操作符，基本能满足开发需要，如需深入了解，可直接阅读源码。最后上图来验证以上方法：

二、RxJava—合并（Merge）合并的是两个被观察者发送的消息序列。

1、头尾相接用Observable的merge方法。

subscription = Observable.merge(Observable.from(iarray), Observable.from(jarray)).subscribe(new Action1<Integer>() {
                            @Override
                            public void call(Integer integer) {
                                adapter.add(integer);
                            }
                        });
                subscription.unsubscribe();

2、相交合并用Observable的zip方法，长度以小的为准。

//iarray1和jarray1分别为两个被观察者要发送的消息序列
subscription = Observable.zip(Observable.from(iarray1), Observable.from(jarray1),new Func2<Integer, Integer, Integer>() {
           @Override
           public Integer call(Integer integer, Integer integer2) {
                    //这里返回的是合并后的消息序列，如何合并可以任意定义
                                return integer + integer2;
                          }
                        }).subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer str) {
                        adapter.add(str);
                    }
                });
                subscription.unsubscribe();

效果如图：

三、RxJava—转换（Map）

1、转换被观察者发送的消息序列

//list里面存储的是图片id，这里存储了两个一样的id
subscription = Observable.from(list).repeat(2).map(new Func1<Integer, Bitmap>() {
                    @Override
                    public Bitmap call(Integer integer) {
                    //将图片id转换为bitmap再发送给观察者
     return BitmapFactory.decodeResource(getResources(), integer);
                    }
                }).subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(final Bitmap bitmap) {
                        bitList.add(bitmap);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        mapAdapter.notifyDataSetChanged();
                    }
                });
                subscription.unsubscribe();

2、转换被观察者，当被观察者发送的是一个对象的集合，但我们实际需要发送的是对象内部的集合，我们可以通过for循环把集合中的对象一个个取出来并获取对象内部集合再创建新的Observable进行发送，Observable提供了flatMap也可以帮助我们解决这个需求。

//infoLists即为对象集合
subscription = Observable.from(infoLists)
                        .flatMap(new Func1<InfoList, Observable<Integer>>() {
                            @Override
                            public Observable<Integer> call(InfoList infoList) {//infoList即为每一个对象
           //将对象中的集合取出来再通过Observable发送消息序列
           return Observable.from(infoList.getList()).repeat(2);
                            }
                        }).subscribe(new Observer<Integer>() {
                            @Override
                            public void onCompleted() {
                                mapAdapter.notifyDataSetChanged();
                            }
                            @Override
                            public void onError(Throwable e) {
                            }
                            @Override
                            public void onNext(Integer integer) {   bitList.add(BitmapFactory.decodeResource(getResources(),integer));
                            }
                        });
                subscription.unsubscribe();

效果如图：

在这里Observable的操作符部分就讲完了，并不是全部，但都是常用的，如果不是特别理解，可以下载demo理清思路：传送门