前言#

上一篇已經(jīng)把一些基礎(chǔ)的api都介紹了，這次再多聊一些api以及如何進(jìn)行線程切換。

正文#

首先我們來聊一聊線程切換的問題，例如最近非常流行的RxAndroid + Retrofit + OkHttp，典型的框架之間的結(jié)合使用，那么問題來了，Android是不允許在主線程發(fā)起的，沒有線程切換那就肯定要蛋疼了，例如下面的偽代碼：

Observable<String>
// 這些都在新線程里
.map("對url進(jìn)行一些處理，例如一些公共參數(shù)的拼接等等")
.flatMap("通過發(fā)起網(wǎng)絡(luò)請求，把String轉(zhuǎn)換成我們想要的bean")
.map("對bean進(jìn)行判斷，例如請求碼之類的")
// 回調(diào)在主線程中
.subscribe("回調(diào)監(jiān)聽");

我們希望指定某些代碼是在特定的線程去執(zhí)行，所以這個時候就需要使用 subscribeOn()，observeOn() ，從命名我們大概看的出來，subscribeOn估計就是設(shè)置回調(diào)的線程，observeOn應(yīng)該是指定觀察的線程，也就是除了subscribe以外的代碼。

observeOn() 指定的是它之后的操作所在的線程，這對于邏輯也很有幫助，對之后的代碼有效，并且可以調(diào)用多次。

subscribeOn（）理論上是應(yīng)該只調(diào)用一次的，他只對subscribe有作用，并且只有第一次有效，具體為什么大家可以自己去查一查資料，了解一下內(nèi)部的原理。

ok，最后再看看可以指定哪些線程：

Schedulers.io() : io線程池，例如文件讀寫之類的操作
Schedulers.computation() ：執(zhí)行計算相關(guān)的操作
Schedulers.newThread()：新線程
AndroidSchedulers.mainThread() ：Android主線程，也就是UI線程。

上面就是我們常用的線程，當(dāng)前還有其他的，不過用的很少就不提了。這樣我們就可以對上面的偽代碼進(jìn)行修改：

Observable<String>
// 這些都在新線程里
.observeOn(Schedulers.newThread())
.map("對url進(jìn)行一些處理，例如一些公共參數(shù)的拼接等等")
.flatMap("通過發(fā)起網(wǎng)絡(luò)請求，把String轉(zhuǎn)換成我們想要的bean")
.map("對bean進(jìn)行判斷，例如請求碼之類的")
// 回調(diào)在主線程中
.subscribeOn(AndroidSchedulers.mainThread())
.subscribe("回調(diào)監(jiān)聽");

是不是非常的簡單，所以就省去了我們大量的Handler.post()或者是RunOnUIThread（）代碼和忽然發(fā)現(xiàn)沒有Context的尷尬情況。

<h2>其他的一些api</h2>

最后再聊聊一些其他的api，工作里面也可能會用到：

reduce : 減少被觀察者的對象數(shù)量。

reduce(new BiFunction<School, School, School>() {
            @Override
            public School apply(@NonNull School school, @NonNull School school2) throws Exception {
                return null;
            }
        });

有時候我們通過flatMap增加了很多的被觀察者，同樣我們還可以減少被觀察者，從參數(shù)就看的出來，看一個小demo：

private class School {

        public String[] student = {"111", "222", "222", "222", "222", "222", "222", "222", "222", "222", "222"};

    }
    
Observable.just(new School())
.flatMap(new Function<School, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull School school) throws Exception {
                return Observable.fromArray(school.student);
            }
        })
.reduce(new BiFunction<String, String, String>() {
            @Override
            public String apply(@NonNull String s1, @NonNull String s2) throws Exception {
                return s1 + s2;
            }
        })
.subscribe(new MaybeObserver<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {

            }

            @Override
            public void onSuccess(@NonNull String s) {
                    Log.e("lzp",  s);
            }

            @Override
            public void onError(@NonNull Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

非常簡單的代碼，我把School對象通過flatMap映射出多個字符串對象，然后我再reduce，把字符串拼合起來，那么我得到的結(jié)果是什么呢？

06-20 17:46:47.747 26423-26423/com.lzp.rxjavastudy E/lzp: 111222222222222222222222222222222

最后得到了一個由數(shù)組里所有的字符串拼成的大字符串。

compose：英文是組成的意思，他最大的特點就是用在封裝上，例如可以把相同的封裝起來，像之前提到的公共參數(shù)，直接封裝成Obsever然后就拼接到想要的Obsever中就可以了。

Observable.just(new School()).flatMap(new Function<School, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull School school) throws Exception {
                return Observable.fromArray(school.student);
            }
        }).compose(new ObservableTransformer<String, String>() {
            @Override
            public ObservableSource<String> apply(@NonNull Observable<String> upstream) {
                return upstream.map(new Function<String, String>() {
                    @Override
                    public String apply(@NonNull String s) throws Exception {
                        return s + "hahaha";
                    }
                });
            }
        })...

上面的代碼增加compose，對所有的String都拼接了hahaha，看一下結(jié)果:

06-20 18:04:21.353 15429-15429/? E/lzp: 111hahaha222hahaha222hahaha222hahaha222hahaha222hahaha222hahaha222hahaha222hahaha222hahaha222hahaha

distinct() : 去除重復(fù)對象。

有時候我們列表里可能會有相同的對象，例如我的字符串?dāng)?shù)組中有好多的 111 ，222，如果我只想保留一個，我就可以直接調(diào)用distinct():

 Observable.just(new School()).flatMap(new Function<School, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull School school) throws Exception {
                return Observable.fromArray(school.student);
            }
        }).distinct().compose...

在compose之前加上distinct（）方法，看一些結(jié)果：

06-20 18:08:43.618 21419-21419/com.lzp.rxjavastudy E/lzp: 111hahaha222hahaha

跟我預(yù)想的完全一樣。

總結(jié)#

我也是剛接觸RxJava沒多久，寫的東西都是非常基礎(chǔ)的使用場景，還有很多很多的api都還沒有使用過，但是RxJava的特性確實讓人眼前一亮，讓開發(fā)者省去了大量的精力去思考如何更新UI等等蛋疼的問題，如果再有更深的體會，再寫一寫新的東西出來跟大家分享。