天天看點

RxJava—操作符(過濾、合并、轉換)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().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().subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        adapter.add(s);
                    }
                });
                subscription.unsubscribe();
           

5、ElementAt

如何你需要發送指定的某一條資料,可以使用Observable的elementAt方法。

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

這裡舉例的是幾種常用的過濾操作符,基本能滿足開發需要,如需深入了解,可直接閱讀源碼。最後上圖來驗證以上方法:

RxJava—操作符(過濾、合并、轉換)RxJava—過濾、合并、轉換

二、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—操作符(過濾、合并、轉換)RxJava—過濾、合并、轉換

三、RxJava—轉換(Map)

1、轉換被觀察者發送的消息序列

//list裡面存儲的是圖檔id,這裡存儲了兩個一樣的id
subscription = Observable.from(list).repeat().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();
                            }
                        }).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();
           

效果如圖:

RxJava—操作符(過濾、合并、轉換)RxJava—過濾、合并、轉換

在這裡Observable的操作符部分就講完了,并不是全部,但都是常用的,如果不是特别了解,可以下載下傳demo理清思路:傳送門