Kotlin快速入坑指南（干貨型文檔）

又是一篇Kotlin的文章，為啥...還不是因為工作需要。毫無疑問，最好的學(xué)習(xí)方式是通過官方文檔去學(xué)習(xí)。不過個人覺得官方文檔多多少少有一些不夠高效。

中文官方文檔

因此這篇是從我學(xué)習(xí)的個人視角以文檔的形式去輸出Kotlin語言基礎(chǔ)的學(xué)習(xí)。
不扯淡了，開整。
<p style="text-align:center;color:#42A5F5;font-size:2em;font-weight: bold;">正文

1、高階函數(shù)

高階函數(shù)是將函數(shù)用作參數(shù)或返回值的函數(shù)。

個人為什么把這個語言特性放在第一位，因為我覺得這是我們Java語言中所不支持的。然而這個特性基本貫穿整個Kotlin語言體系。所以個人把它放到了第一位，也希望各位小伙伴能夠重視這個小小的特性。先看看一個小小的demo，感受一下這個特別特性：

// 函數(shù)定義
fun funtion(num: Int, innerFun: (Int) -> Int): Int {
    return innerFun(num)
}

簡單解釋一下上邊的代碼。我們先看函數(shù)定義，這里定義了一個名為funtion并且返回值為Int的函數(shù)，此外這個函數(shù)接受一個Int參數(shù)和一個函數(shù)類型的參數(shù)（這個函數(shù)需要傳遞一個Int參數(shù)，并且返回一個Int值）。
接下來我們調(diào)用一下：

// 函數(shù)調(diào)用
val result = funtion(1) {
    it + 666
}

對于Lambda來說，入?yún)⑷绻且粋€的話可以用it來表示

說實話，第一次我看到這種調(diào)用的時候，是一臉懵逼的。不知道剛?cè)肟拥男』锇槭遣皇呛臀乙粯拥母惺?？因為這種寫法包含小tips：
我們的innerFun是可以被簡化為一個Lambda，而當(dāng)Lambda作為函數(shù)的最后一個參數(shù)時，是可以將其寫在函數(shù)之外的。也就是Demo中的funtion(1){}。

此外我們要注意一點，這里我們的函數(shù)實例，并沒有return，這是因為。lambda 表達(dá)式中的最后一個表達(dá)式是返回值
實際上這就是相當(dāng)于調(diào)用了funtion方法的倆個參數(shù)，咱們換一種傳統(tǒng)的寫法，二者是等價的：

val inner = fun(num: Int): Int {
return num + 1
}
val result = funtion(1, inner)

OK，接下來咱們趁熱打鐵，再感受感受函數(shù)操作的“騷操作”。接下來我們看一看其實情況下的用法：

// 函數(shù)定義1
fun funtion(num: Int, innerFun: (Int, Int) -> Int): Int {
return innerFun(num, num + 1)
}
// 函數(shù)調(diào)用1（上文提到，入?yún)?個可以用it表示，那么倆個或者多個呢？我們可以如下，自定義）
val result = funtion(1) { num1, num2 ->
num1 + num2 + 666
}
// 函數(shù)調(diào)用2（除了Lambda的調(diào)用方式，我們還可以用匿名函數(shù)，二者是一樣的）
val result = funtion(1, fun(num1: Int, num2: Int): Int {
return num1 + num2 + 666
}

OK，關(guān)于高階函數(shù)的內(nèi)容，就聊這么多，因為有了這個其實，很多內(nèi)容也就很好上手了。接下來就讓我們一同看看基于高階函數(shù)的內(nèi)置封裝。

2、操作符

集合操作符

個人覺得，Kotlin操作符中。開發(fā)中頗為常用的是集合操作符，比如我們有時需要對一些數(shù)據(jù)進(jìn)行連續(xù)的轉(zhuǎn)化，我們可能會使用RxJava；

Observable.create(new ObservableOnSubscribe<List<CustomModel>>() {
            @Override
            public void subscribe(ObservableEmitter<List<CustomModel>> e) throws Exception {
                // 省略構(gòu)建List<CustomModel>
                e.onNext(data);
            }
        }).flatMap(new Function<List<CustomModel>, ObservableSource<CustomModel>>() {
            @Override
            public ObservableSource<CustomModel> apply(List<CustomModel> customModels) throws Exception {
                return Observable.fromIterable(customModels);
            }
        }).map(new Function<CustomModel, String>() {
            @Override
            public String apply(CustomModel customModel) throws Exception {
                return customModel.name;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                // 操作s
            }
        });

這里簡單，寫了一個RxJava的Demo：我們有一個List集合，先把它一個個發(fā)送，然后把每一個數(shù)據(jù)轉(zhuǎn)成String，最后去String進(jìn)行處理。
而在Kotlin中，應(yīng)對上述的需求，我們該怎么做？由于操作符的支持，我們可以極為方便的進(jìn)行這類操作：

val data = arrayListOf<CustomModel>(// ...省略構(gòu)建的過程)
val newData=data.map {
    it.name
}.forEach {
    // 操作it
}

用法很簡單，乍一看很唬人。但是其實很簡單，回憶一下我們再開篇奠定的高階函數(shù)的基礎(chǔ)。這里其實就是調(diào)用了data的擴(kuò)展函數(shù)map（拓展函數(shù)是一種語法，可以拓展現(xiàn)有的類。比如這個map就是拓展了Iterable，下文我們會展開它的實現(xiàn)）。對它進(jìn)行類型轉(zhuǎn)變，然后進(jìn)而調(diào)用forEach自動對這個集合進(jìn)行遍歷。

接下來讓我們點進(jìn)去，看一看具體的實現(xiàn)：

// 注意看，這里map的**返回值**，是一個List<R>，也就是說最終將返回map后的類型集合。因此我們可以繼續(xù)進(jìn)行鏈?zhǔn)秸{(diào)用。
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
    return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}

public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C {
    for (item in this)
        destination.add(transform(item))
    return destination
}

說白了，這里的集合操作符就是把轉(zhuǎn)化的實現(xiàn)通過參數(shù)的形式暴露出來，由我們自行去處理，其他的事情，有內(nèi)部封裝去做。
當(dāng)然，這其中還有很多有趣的操作符，各位小伙伴可以自行去了解。不過原理都是大同小異~

3、作用域函數(shù)

上述我們聊的是作用在集合上的操作符，說白了。它們就是拓展在對應(yīng)集合類上的函數(shù)而已。那么可能有小伙伴會問，有沒有作用在對象上的？沒錯，是有的。也就是我們接下來要聊的：作用域函數(shù)。

其實很常見：

"Kotlin".let{
    it.toInt()
}
"Kotlin".run{
    this.toInt()
}

"Kotlin".apply{
}
"Kotlin".also{
}

public inline fun <T, R> T.let(block: (T) -> R): R
public inline fun <T, R> T.run(block: T.() -> R): R

public inline fun <T> T.apply(block: T.() -> kotlin.Unit): T
public inline fun <T> T.also(block: (T) -> kotlin.Unit): T

咱們看一下，它們哥四個的定義，其實很清晰。這里以返回值的類型，倆倆分類：

• let/run。這倆個函數(shù)都可以返回另一種類型；不同在于let有入?yún)?，而run沒有。
• also/apply。 這倆個函數(shù)返回值都是本身，其中apply沒有入?yún)?，而also有。

  不過即使沒有入?yún)?，也可以通過this，得到本身。

上述函數(shù)的作用還是挺方便的，比如：

Model model ;
// ...省略初始化過程
if(model!=null){
    // 省略大段的操作邏輯
}

這種寫法，在kotlin中可以這么寫：

model?.alse{
    // 省略大段的操作邏輯
}
// 有需求我們可以繼續(xù)調(diào)用它的作用域函數(shù)

如果你還有一些else操作，那么沒轍了，kotlin中也只能老老實實if-else

當(dāng)然，還有一些有趣的作用域函數(shù)，比如在Java中：

boolean isTure;
// 省略boolean判斷邏輯
if(isTure){
    // 省略大段的操作邏輯
}

到Kotlin中可以這樣來搞：

某對象.takeIf{
    // boolean判斷邏輯
}?.{
    // 省略大段的操作邏輯
}
// 有需求我們可以繼續(xù)調(diào)用它的作用域函數(shù)

takeIf：會根據(jù)入?yún)⒌暮瘮?shù)的返回值（true/false），決定自己（takeIf）的返回值是null還是調(diào)用者。如果是false，那么就會返回null，因此這里使用?的方式繼續(xù)去調(diào)用后續(xù)操作。
我個人比較喜歡作用域函數(shù)， 因為可以省略很多if。接下來我們來換個稍稍復(fù)雜的邏輯：已知一個方法，入?yún)⑹且粋€Model，我們要判斷當(dāng)這個Model對象的age屬性大于10，打印這個Model對象的名字。
對于Java來說，我們可能這么寫：

public void fun(Model model) {
    // 寫了3個if。
    if (model != null) {
        if (model.age>10){
            if (model.name!=null){
                // 打印model.name
            }
        }
    }
}

class Model {
    String name;
    int age;
}

對于Kotlin來說，我們可以這么寫：

fun funtion(model : Model){
    model?.takeIf{
        it.age > 10
    }?.let{
        // 打印it.name
    }
}

是不是簡潔了很多？但是單說簡潔這種東西，似乎并沒有什么卵用...不過寫起來，真的很爽！不信，大家可以試試~~

<p style="text-align:center;color:#42A5F5;font-size:2em;font-weight: bold;">尾聲

這篇文章，想聊的內(nèi)容就這么多。個人認(rèn)為其實理解了高階函數(shù)，（PS：不知道為啥起了個名叫高階函數(shù)，整得好像很高級似的。）Kotlin就可以很快的上手，并且能感受到Kotlin寫起來的爽快之處~
這里的確有些安利的意味。那是因為自己最開始對新技術(shù)其實接受度并不高，總認(rèn)為新東西有各種各樣的問題...當(dāng)自己去了頭條之后，才發(fā)現(xiàn)身邊的同事那種高昂的學(xué)習(xí)勁頭，（Kotlin？對他們來說不叫新東西...Jatpack，F(xiàn)lutter都已經(jīng)在線上項目中跑了）自己還有什么理由說：求求別更新了，我學(xué)不動了...
還是那句話：干就完了！