全網最全面的由淺到深的Kotlin基礎教程（七）

前言

本篇文章接著上一篇文章全網最全面的由淺到深的Kotlin基礎教程（六）繼續進階學習kotlin，建議看完上一篇文章，再來看本篇文章。本篇主要分析一些常用的kotlin函數源碼，以及用kotlin簡單實現Rxjava的幾個操作符。堅持將kotlin系列的前6篇看完的，那么恭喜你再將這最后一篇看完，你就成為一名合格的kotlin開發者了。

1. kotlin標準函數源碼解析

1.1 apply

源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T> 泛型定義
T.apply 泛型T的擴展函數
(block: T.() -> Unit) 輸入參數為一個名為block的lambda表達式，其中T.() 是一個泛型擴展函數，這種寫法使得lambda表達式持有T的this對象，當做固定寫法來理解即可。
: T apply函數的返回類型仍然為T
*/
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {//契約函數，暫時不用關注，可以不寫的contract {callsInPlace(block, InvocationKind.EXACTLY_ONCE)}//執行lambda表達式的邏輯block()//最終仍然返回T對象本身return this
}

1.2 also

與apply函數的意義一樣，只是also函數的lambda表達式持有it，而apply函數的的lambda表達式持有this，源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T> 泛型定義
T.also 為泛型T定義擴展函數also
block: (T) -> Unit also函數中傳入的參數是lambda表達式，該lambda表達式有一個T泛型的參數，返回值為空
: T also函數的最終返回值仍然為T泛型
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.also(block: (T) -> Unit): T {contract {callsInPlace(block, InvocationKind.EXACTLY_ONCE)}//執行lambda表達式，將T泛型的this對象傳入block函數，因此block通過it持有T泛型的this對象block(this)//不管你上面的lambda表達式干了啥，最終仍然返回T泛型對象本身return this
}

1.3 run

源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T, R> 定義兩個泛型
T.run 為T泛型定義擴展函數run
block: T.() -> R run函數有一個參數是lambda表達式，該lambda表達式通過T泛型擴展函數，擁有T泛型的this對象，返回類型為R
: R run函數的返回類型是R泛型
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> T.run(block: T.() -> R): R {contract {callsInPlace(block, InvocationKind.EXACTLY_ONCE)}//執行lambda表達式//因為lambda表達式擁有T泛型的this對象//因為lambda表達式返回的是R，因此返回值由lambda表達式的最后一行決定//return this.block()  //this可以省略return block()
}

1.4 let

與run函數的意義一樣，只是let函數的lambda表達式持有it，而run函數的的lambda表達式持有this，源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T, R> 定義兩個泛型
T.let 為T泛型定義擴展函數let
block: (T) -> R lambda表達式參數，輸入T泛型（lambda表達式如果只有一個參數，則參數名默認為it），輸出為R泛型
: R 最終返回的類型是R泛型
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> T.let(block: (T) -> R): R {contract {callsInPlace(block, InvocationKind.EXACTLY_ONCE)}//執行lambda表達式//因為lambda表達式傳入的是this，因此lambda表達式通過it持有T泛型的對象//因為lambda表達式輸入的T，返回的是R，因此返回值由lambda表達式的最后一行決定return block(this)
}

1.5 with

與run函數的意義一樣，只是調用方式不一樣而已，run是泛型擴展函數，而with是普通的函數，源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T, R> 定義兩個泛型
with(receiver: T, block: T.() -> R) 這是一個普通的函數，并非擴展函數，包括兩個參數，第一個T泛型的參數，第二個是lambda表達式，lambda表達式通過T泛型擴展函數，擁有T泛型的this對象，返回類型為R
: R 最終返回類型是R
*/
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {contract {callsInPlace(block, InvocationKind.EXACTLY_ONCE)}//block的最后一行是返回值return receiver.block()
}

1.6 takeIf

源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T> 泛型定義
T.takeIf 為泛型T定義擴展函數takeIf
predicate: (T) -> Boolean takeIf函數中傳入的參數是lambda表達式，該lambda表達式有一個T泛型的參數，返回值為Boolean
: T? takeIf函數最終返回的可空的T泛型類型
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {contract {callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)}//如果lambda表達式返回true，則takeIf返回T泛型this對象本身，否則返回nullreturn if (predicate(this)) this else null
}

1.7 takeUnless

與takeIf的意義相反，源碼及分析注釋如下：

/*
public 訪問修飾符
inline fun 內聯函數
<T> 泛型定義
T.takeUnless 為泛型T定義擴展函數takeUnless
predicate: (T) -> Boolean takeUnless函數中傳入的參數是lambda表達式，該lambda表達式有一個T泛型的參數，返回值為Boolean
: T? takeIf函數最終返回的可空的T泛型類型
*/
@kotlin.internal.InlineOnly
@SinceKotlin("1.1")
public inline fun <T> T.takeUnless(predicate: (T) -> Boolean): T? {contract {callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)}//如果lambda表達式返回false，則takeUnless返回T泛型this對象本身，否則返回nullreturn if (!predicate(this)) this else null
}

2. kotlin轉換函數源碼解析

2.1 map

功能介紹：
源碼及分析注釋如下：把lambda表達式的返回結果（最后一行），添加到新的集合destination中，并返回。
示例代碼：

fun main() {var list = listOf("A", "B", "C")list.map {"[$it]"}.map {"[$it, len=${it.length}]"}.map {print("$it ")}}

運行結果如下：
在這里插入圖片描述

源碼分析：

//Iterable類的擴展函數map
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {//將創建的List數組和lambda表達式傳入mapTo函數//return this.mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform) //this可以省略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 {//遍歷調用map的List對象for (item in this)//將原有的list值傳遞給lambda表達式transform處理，并存入新的集合destinationdestination.add(transform(item))return destination //返回新的集合
}

2.2 flatmap

功能介紹：
lambda表達式的返回結果是一個集合，把lambda表達式的返回集合，通過addAll函數鋪開，并添加到新的集合destination中，最后返回新的集合。
示例代碼：

fun main() {var list = listOf("A", "B", "C")list.flatMap {listOf("[$it ,", "$it]")}.map {print("$it ")}
}

運行結果如下：
在這里插入圖片描述

源碼分析：

//Iterable類的擴展函數
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {return flatMapTo(ArrayList<R>(), transform)
}public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C {//遍歷flatMap調用者的集合元素for (element in this) {//lambda表達式返回一個集合val list = transform(element)//將lambda表達式返回的集合添加到新的集合destination中destination.addAll(list)}//返回新的集合return destination
}

2.3 filter

功能介紹：
如果lambda表達式的返回值為true，則遍歷當前元素，加入新的字符串構造器StringBuilder destination，否則，不加入新的字符串。最后返回新的字符串
示例代碼：

fun main() {var list = listOf("A", "B", "C")list.map {//過濾list中為A的元素it.filter { it ->println("$it filter")it == 'A'}}.map {print("$it  ")}
}

運行結果如下：
在這里插入圖片描述

源碼分析：

//String類的擴展函數filter
public inline fun String.filter(predicate: (Char) -> Boolean): String {return filterTo(StringBuilder(), predicate).toString()
}public inline fun <C : Appendable> CharSequence.filterTo(destination: C, predicate: (Char) -> Boolean): C {//遍歷filter調用者的字符串的所有字符for (index in 0 until length) {val element = get(index)//如果這個字符傳入lambda表達式predicate的返回結果為true，則添加到StringBuilder中if (predicate(element)) destination.append(element)}//返回新的字符串StringBuilderreturn destination 
}

2.4 zip

功能介紹
通過lambda表達式將第一個集合和另一個集合，以Pair的形式添加到新的集合中，并返回
示例代碼

fun main() {val name = listOf("sun", "mekeater")val age = listOf(18,19)var zip = name.zip(age)//將zip轉為Map遍歷zip.toMap().forEach{println("name=${it.key},age=${it.value}")}
}

運行結果如下：
在這里插入圖片描述

源碼分析

//Iterable類的擴展函數zip
public infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>> {return zip(other) { t1, t2 -> t1 to t2 }
}
//中綴表達式，將A和B組合成一個Pair對象
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)public inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V> {//zip函數調用者對象遍歷器val first = iterator()//zip函數中傳入的另一個集合對象遍歷器val second = other.iterator()//新建集合val list = ArrayList<V>(minOf(collectionSizeOrDefault(10), other.collectionSizeOrDefault(10)))//遍歷兩個集合while (first.hasNext() && second.hasNext()) {//將兩個集合的元素傳給lambda表達式transform//上面可以看到transform的實現，是將兩個參數組合為一個Pair//將Pair對象添加到新的集合list中list.add(transform(first.next(), second.next()))}//返回新的集合return list
}

3. 函數式編程理解

kotlin是函數式編程語言，函數式編程語言的代碼更簡潔直觀（如果你會的話，真的很容易讀懂，但如果不會，那真的又一一點看不懂，相信認真看了我kotlin這7篇文章的，到這兒應該都能輕松的讀懂下的kotlin代碼），我們以一段示例代碼來對比下，函數式編程和普通編程方式的區別。

如下一段kotlin函數式編程，用普通的java代碼寫，需要寫一堆才能實現

fun main() {val name = listOf("sun", "mekeater")val age = listOf(18,19)//name.zip(age) 將name和age兩個集合組成鍵值對集合//.toMap() 將上一步鍵值對集合轉為Map集合//.map { "name:${it.key},age:${it.value}"} 遍歷上一步Map集合中的元素，按照"name:${it.key},age:${it.value}"格式進行組合//.map { println(it) 遍歷上一步Map集合中的元素,進行打印輸出name.zip(age).toMap().map { "name:${it.key},age:${it.value}"}.map { println(it) }
}

對上面的kotlin函數式編程寫的代碼用java實現，示例代碼如下：

public class Kt43_java {public static void main(String[] args) {List<String> names=new ArrayList<>();names.add("sun");names.add("mekeater");List<Integer> ages =new ArrayList<>();ages.add(18);ages.add(19);Map<String, Integer> map =new LinkedHashMap<>();for (int i = 0; i < names.size(); i++) {map.put(names.get(i), ages.get(i));}List<String> newList=new ArrayList<>();for (Map.Entry<String, Integer> stringIntegerEntry : map.entrySet()) {newList.add("name:"+stringIntegerEntry.getKey()+" age:"+stringIntegerEntry.getValue());}for (String s : newList) {System.out.println(s);}}}

kotlin的一行代碼，java要用一堆才能實現，kotlin代碼的簡潔程度不言而喻！

4. 手寫RxJava

采用kotlin代碼實現RxJava的create，map，observer三個操作符，通過這個示例，真的更能感受到kotlin代碼的簡潔程度令人發指，哈哈哈

fun main() {create {"mekeater"}.map {"[$this]"}.map {"==$this=="}.observer {println(this)}
}
class RxjavaCoreClass<T>(val item:T)//lambda對輸入進行處理
inline fun<I> RxjavaCoreClass<I>.observer(observerAction:I.()->Unit):Unit = observerAction(item)//對于輸入進行處理，轉換為輸出給到RxjavaCoreClass
inline fun<I,O> RxjavaCoreClass<I>.map(mapAction:I.()->O) = RxjavaCoreClass(mapAction(item))//create操作符只是將用戶最后一行的輸入原樣輸出給RxjavaCoreClass，起到一個輸入參數的作用
inline fun<O> create(action:()->O) = RxjavaCoreClass(action())