RxJava2.x之變換操作符

參考資料 https://mcxiaoke.gitbooks.io/rxdocs/content/

1.buffer

根據緩衝容量大小發送新的觀察者對象，接收的是緩衝區元素組成的集合體。

Observable.just("111", "222", "333", "444", "555")
         .buffer(3)
         .subscribe(new Observer<List<String>>() {
             @Override
             public void onSubscribe(Disposable d) {
             }
             @Override
             public void onNext(List<String> strings) {
                 Log.d("buffer", "onNext: 接收的數據--->" + strings.size() + "  " + strings);
             }
             @Override
             public void onError(Throwable e) {
             }
             @Override
             public void onComplete() {
             }
         });
/**
 * 輸出結果
 * 03-27 14:24:30.048 14508-14508/com.example.testlink D/buffer: onNext: 接收的數據--->3  [111, 222, 333]
 * 03-27 14:24:30.048 14508-14508/com.example.testlink D/buffer: onNext: 接收的數據--->2  [444, 555]
 */

如果上游發射對象是這樣的：

int[] is = new int[]{1,2,3,4,5,6,7};
Observable.fromArray(is).buffer(3)

那麼下游接收的數據是：

/**
 * 03-27 14:33:14.358 14596-14596/com.example.testlink D/buffer: onNext: 接收的數據--->1  [[I@41b4c990]
 */

 結果最終的輸出集合體大小是1，內容是一個對象地址值。因爲上游只發射一個數據過來。

2.Map

可以將任意發射數據轉換成任意數據類型或對象，靈活度高。

Observable.just("100").map(new Function<String, Integer >() {
    @Override
    public Integer apply(String s) throws Exception {
        Log.d("map", "apply: " + s);
        return 10086;
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(Integer integer) {
        Log.d("map", "onNext:接收的數據--->  " + integer);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
    }
});
/**
 * 將上游發射的 String 類型 轉換成 integer 數據類型後發射給下游接收。
 * 03-27 15:36:07.138 15066-15066/com.example.testlink D/apply: apply: 100
 * 03-27 15:36:07.138 15066-15066/com.example.testlink D/map: onNext:接收的數據--->  10086
 */

3.flatMap

同樣是類型轉換，與Map相比的區別就是：Map轉換後發射的數據類型可以是任意，但是flatMap轉換後反射出去的是一個新的觀察者對象：ObservableSource。

List<String> list2 = new ArrayList<>();
list2.add("資源a");
list2.add("資源b");
list2.add("資源c");
list2.add("資源d");
user user2 = new user("yy", "20", list2);
Observable.just(user2).flatMap(new Function<user, ObservableSource<user>>() {
    @Override
    public ObservableSource<user> apply(user s) throws Exception {
        Log.d("flatMap", "apply: " + s.age);
        return Observable.just(new user(s.age));
    }
}).subscribe(new Observer<user>() {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(user o) {
        Log.d("flatMap", "onNext:接收的數據---> " + o.name);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
    }
});
/**
 * 03-27 15:58:52.458 15434-15434/? D/flatMap: apply: 20
 * 03-27 15:58:52.458 15434-15434/? D/flatMap: onNext:接收的數據---> pp
 */

 簡單user類：

public class user {
    public String name;
    public String age;
    public List<String> nets;
    public user(String name, String age, List<String> nets) {
        this.age = age;
        this.name = name;
        this.nets = nets;
    }
    public user(String age) {
        this.age = age;
        this.name = "pp";
        this.nets = null;
    }
}

 上面邏輯是將一個user對象同過flatMap拿到發射user對象的age，賦值給一個新的user對象，最後打印新的user的name。當然也可以轉換成另外的ObservableSource類型數據。

4.GroupBy

直接字面上的意思理解就是分組。根據某種條件將發射出去的數據進行分組。

 Observable.just(0, 1, 2, 3, 4, 5, 6)
                .groupBy(new Function<Integer, Boolean>() {
                    @Override
                    public Boolean apply(Integer integer) throws Exception {
                        return integer % 2 == 0;
                    }
                }).subscribe(new Observer<GroupedObservable<Boolean, Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(GroupedObservable<Boolean, Integer> object) {
//                Log.d("groupBy", "accept1:接收的數據類型---> " + object.getKey());
                object.subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d("groupBy", "accept2:接收的數據類型---> "+object.getKey() +" --> "+ integer);
                    }
                });
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
        });
        /**
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> true --> 0
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> false --> 1
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> true --> 2
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> false --> 3
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> true --> 4
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> false --> 5
         * com.example.testlink D/groupBy: accept2:接收的數據類型---> true --> 6
         */

5.scan

看官方解釋：

* Returns an Observable that applies a specified accumulator function to the first item emitted by a source
* ObservableSource, then feeds the result of that function along with the second item emitted by the source
* ObservableSource into the same function, and so on until all items have been emitted by the source ObservableSource,
* emitting the result of each of these iterations.
* <p>

這個意識大概說返回一個觀察對象，這個對象通過某種方法先應用在第一個發射數據，然後將這個結果應用在發射的第二項數據上，直到最後一個發射數據。假定給他定義的方法是加法，每次發射的數據源是int 值，那麼最終的結果就是全部發射數據的和了。

Observable.just(1, 2, 3, 4, 5)
        .scan(new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                Log.d("scan", "integer: " + integer + "  integer2= " + integer2);
                return integer + integer2;
            }
        }).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
    }
    @Override
    public void onNext(Integer integer) {
        Log.d("scan", "onNext: " + integer);
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
    }
});
/**
 * /com.example.testlink D/scan: onNext: 1
 /com.example.testlink D/scan: integer: 1  integer2= 2
 /com.example.testlink D/scan: onNext: 3
 /com.example.testlink D/scan: integer: 3  integer2= 3
 /com.example.testlink D/scan: onNext: 6
 /com.example.testlink D/scan: integer: 6  integer2= 4
 /com.example.testlink D/scan: onNext: 10
 /com.example.testlink D/scan: integer: 10  integer2= 5
 /com.example.testlink D/scan: onNext: 15
 */

這裏第一次打印沒有走加法運算，而是直接到next裏面去了，第二次纔開始走加法運算，第一個參數是這個方法產生的結果，第二個參數是發射的數據源。

6.window

Observable.just(1, 2, 3, 4, 5, 6, 7)
        .window(5)
        .subscribe(new Observer<Observable<Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {
            }
            @Override
            public void onNext(Observable<Integer> ob) {
                ob.subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d("window", "accept: 接受的數據----> " + integer);
                    }
                });
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
        });
/**
 * 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 1
 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 2
 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 3
 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 4
 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 5
 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 6
 03-27 17:42:07.418 16433-16433/com.example.testlink D/window: accept: 接受的數據----> 7
 */

emmm，看到這個日誌是懵的，沒看出什麼特別的地方。查閱一下文檔後從下面這個圖來理解的話，window作用是根據count的數量將發射的數據源分組。

上面就是一些常用到的轉換的操作符，列舉的例子都是很簡單的舉例。當然這並不是所有的轉換操作符都在這兒，沒有列舉的，碰到的在以後慢慢探索。

每天進步一點點！U_QAQ_U