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理清思路：傳送門