Lambda和高階函數

本文鏈接：

lambda

1、lambda的由來

1. 單詞"lambda"源于希臘字母λ（小寫lambda）
2. "Lambda"一詞最早起源于數學中的λ演算（lambda calculus），它是一種函數定義和函數應用的形式系統，由邏輯學家阿隆佐·邱奇（Alonzo Church）在20世紀30年代發明。
3. 邱奇使用λ作為演算中的一個操作符，用于表示匿名函數。他選擇使用希臘字母λ的原因是因為它在字母表中的位置不太常見，這樣可以避免與其他符號混淆。

2、函數的聲明

    // 函數的聲明val method01:()->Unitval method02:(Int, Int)->Unitval method03:(String, Double)->Any // 相當于Objectval method04:(String, Double, Float)->Boolean

3、kotlin中Any和Java的Object有什么區別嗎？

1. Any是所有非空類型的超類型，類似于Java中的Object。Object不能持有null。
2. Any?是所有類型的超類型，包括可空類型。
   Any?可以持有null值

4、函數如何調用/函數的實現（lambda）？invoke是什么？

// 函數變量通過invoke()調用
// ()是運算符重載
// 函數的實現
val method01:()->Unit
method01 = { println("我實現了method01") }
method01() // 調用函數：操作符重載
method01.invoke() // 調用函數：真實方法// 方法三的實現
val method03:(String, Double)->Any // 相當于Object
method03 = {name, number ->println("$name $number")name + number
}
println(method03("wch", 1234567.89))

5、函數的實現（傳入函數）

val method04:(String, Double, Float)->Boolean= fun(name:String, number:Double, age:Float):Boolean = (name+number+age).isEmpty()
method04("wch", 376.23, 1234.5f)

6、單一參數的lambda默認持有it ===> 函數式接口 ===> SAM

    val method05:(Int)->Unit = {print("$it")}

7、下劃線可以拒收 ===> 拒收

    val method06:(Int, Int)->Unit = { _, number->println("$number")}

8、作用是什么？

1. 節省空間
2. 接口版本變化，有的參數沒用了

9、想要允許參數為null，需要用可空類型如String?

val method07:(String?,String)->Unit = {sex, name -> println("$sex,$name")}method07(null, "wch")

10、Lambda不可以使用泛型作為參數類型
11、Lambda參數不可以給默認值 ===> 默認參數
12、Lambda Any->Any

    // 傳入什么，打印什么，還可以返回任何東西val method18:(Any)->Any={println("$it")it // 還可以返回自己}

13、Lambda配合擴展方法 ===> 擴展方法 ===> 官網寫的Funciton，但是接收receiver

    val method19: String.()->Unit = {// this = String本身 == 調用者本身println("你是$this")}"WCH".method19()

14、為什么method19可以成為String的擴展方法？

1. 代碼val method19: String.()->Unit = { ... }表示定義了一個接收者類型為String的擴展函數類型。
2. String.()->Unit表示該函數類型接收一個String作為接收者，并返回Unit類型（即沒有返回值）。
3. 進一步理解：==> 匿名擴展函數

val method18: ()->Unit; // 類型是 函數
val method19: String.()->Unit // 類型是 String的擴展函數
val method20: (String)->Unit // 類型是 函數，該函數的參數是String

15、進一步融合this和it，區分擴展函數 和 參數的區別

val method20: Int.(Int) -> String = {"兩數相加的結果:${this+it}"}
println(1.method20(10))println(method20(1, 10)) // 1, 可以自動插為第一個參數

函數的形式：

fun Int.method21(n:Int):String{return "兩數相加的結果:${this+n}"
}
println(2.method21(22))
// println(method21(2, 22)) // 不可以這樣寫了

輸出（返回類型）

1、Lambda的返回類型：函數

    /**============================* 函數*============================*/// 默認Unitfun t01(){ println() }// 默認Unitfun t02(){4652342.5f}// 默認Unitfun t03(){"Hello!"}// String：顯式指明返回值fun t04():String{return "feather"} // return 還不支持自動推斷類型

2、函數返回函數

    /**==============================* 函數返回函數*=============================*/// ()->Unitfun s01() = {}fun s02() = { println("Haha") }s02()() // 輸出// Booleanfun s03() = run{ true }// 返回的是代碼塊的最后一行s03()// ()->Stringfun s04():()->String = {"Hello"}println(s04()) // Function0<java.lang.String>println(s04()())

3、Java中Lambda是假的

深入探究

4、Lambda深入探究

    // k01()返回的類型是: (Int)->Unitfun k01() = {n:Int -> println(n) }k01()(123)// lambda使用，第一種用的多val methodx2 = {str:String -> str.length}val methodx2s:(String)->Int = {it.length}

5、Kotlin的Lambda如何和Java兼容？源碼機制

1. kotlin編譯器實現(很強大) -> JVM字節碼
2. package kotlin.jvm.functions中定義了Function系列
3. 最多Funciton22，高版本編譯器可以處理>22個參數的情況，低版本會出錯

// val methodx2 = {str:String -> str.length}
Function1 methodx2 = (Function1)null.INSTANCE;

// (String)->Unit
val method3:Function1<String, Unit> = { println(it) }

6、Lambda考題

    //(Int,Int) -> (Int,Int) ->Stringval funX10 = fun(n1:Int,n2:Int):(Int,Int)->String={n1,n2 -> "兩個數相加:${n1 + n2}"}println(funX10(10, 10)(20, 20))// 迷惑點，最外層的n1和n2和內層的n1 n2沒關系

// 函數的函數的函數的函數val k01: (String) -> (Boolean) -> (Int) -> (Float) -> Double ={ it ->{ it ->{ it ->{ it ->123.456}}}}println(k01("AAA")(true)(45)(67.89f))

7、下面的study02()返回的類型是什么？

fun study02() = {lambda:(Int, Int) -> String, studyInfo: String ->lambda(1, 99)
}
// 答案：((Int, Int) -> String, String) -> Unit // 使用：
study02()({n1, n2-> "$n1 + $n2 = ${n1 + n2}" }, "wch")

8、下面study04()返回的類型是什么？

fun study04() = {str:String, num:Int, lambda1:(String)->Unit, lambda2:(Int)->Boolean->lambda1(str)lambda2(num)
}
// 答案：(String,Int,(String)->Unit,(Int)->Unit)->Boolean// 使用：
println(study04()("wch", 123, { println("$it lambda1") }, { it > 99}))

泛型

9、下面返回的類型是什么？

fun <T1, T2, R1, R2> study05() = {str:T1, num:T2, lambda1:(T1)->R1, lambda2:(T2)->R2 ->lambda1(str)lambda2(num)
}
// (T1, T2, (T1)->R1, (T2)->R2) -> R2// 使用：
study05<String, Int, Boolean, Float>()("wch", 22, {it.isEmpty()}, {it.toFloat()})

10、下面的study06不是lambda，是函數。他們的類型是什么？

fun study05() = {Str:String, num: Int, lambda:(Int)->Boolean ->lambda(num)
}
// (String, Int, (Int)->Boolean)->Booleanfun study06() = fun(Str:String, num: Int, lambda:(Int)->Boolean):Boolean{return lambda(num)
}
// (String, Int, (Int)->Boolean)->Boolean

1. Lambda表達式，最后一行作為返回值
2. 函數，最后一行不能作為返回值
3. 必須顯式return
4. 必須顯式指定

函數有隱式的Unit類型返回值

inline原理探究

1、Lambda為什么要內聯？

1. 不使用內聯，會構造出Function0對象，作為參數傳入
2. 代碼內聯，減少方法調用開銷，不再需要創建Function0對象 ===> 內存抖動

fun main() {show{println("Hello Kotlin!")}
}
fun show(lambda:()->Unit){lambda()
}
// 不使用內聯生成代碼：
show((Function0)null.INSTANCE);
public static final void show(@NotNull Function0 lambda) {Intrinsics.checkNotNullParameter(lambda, "lambda");lambda.invoke();
}
// 使用內聯：
int $i$f$show = false;
int var1 = false;
String var2 = "Hello Kotlin!";
System.out.println(var2);

高階函數

===> Compose內部實現，學習

1、高階函數是什么？高階函數 = lambda + 函數

fun a() {}
val a1 = {} // 函數引用，接收，匿名函數
val a2 = a1 // 函數引用
val a3 = ::a // 將函數變成函數引用

2、高階函數就是函數的函數，函數中有lambda

// Lambda開胃菜// 返回Stringfun show01(number:Int, lambda:(Int)->String) = lambda.invoke(number)// 調用函數var r01 = show01(99){it.toString()}// return Intfun show02(n1:Int,n2:Int,n3:Int, lambda: (Int,Int,Int)->Int) = lambda(n1, n2, n3)show02(10, 20, 30){i, i2, i3 ->i + i2 + i3}

3、高階函數例子

// 第一版，高階函數應用
fun main() {loginEngine("wch", "123456")
}private fun loginEngine(name:String, pwd:String){loginServer(name, pwd){code, msg->print("錯誤碼$code 錯誤信息$msg")}
}private fun loginServer(name:String, pwd:String, lambda:(Int, String)->Unit){if(name.isEmpty() || pwd.isEmpty()){lambda(-1, "Empty")return}lambda(1, "Success")
}
// 第二版

4、高階函數

// （一）給泛型增加匿名擴展函數
fun<T> T.myRun01(block: T.(Float) -> Boolean) = block(123.45f)
// this = T本身 = 調用者本身 == Derry// 使用
"Derry".myRun01 {isEmpty()
}// （二）
fun<T> T.derry4(number:Double, mm: T.(Double) -> Unit){mm(number)
}
"Derry".derry4(123.456){// this = 調用者println(this)
}// （三）
fun<T> T.myRunPlus(block: T.(T, T) -> Boolean) = block(this,this)

5、T.() -> Boolean s是什么意思？

1. 對T擴展出匿名函數
2. 匿名函數是 ()->Boolean
3. 該匿名擴展函數只有這個高階函數可以使用，其他地方用不出來

6、多個lambda調用

// (一)
show2(lambda1 = {}, lambda2 = {})
//（二）
show2({}, {})
// (三）
show2({println("Hello")}){println("World!")
}

7、源碼使用高階函數，利用函數引用

show(::lambdaImpl)fun lambdaImpl(){println("HAHA")
}// 函數引用場景
fun lambdaImpl(name:String):Unit{println(name)
}
var r1:Function1<String, Unit> = ::lambdaImpl
var r2:(String)->Unit = ::lambdaImpl
var r3:String.()->Unit = ::lambdaImpl // (String)等價于String.()

集合、泛型

1、Lambda+集合+泛型

class AndroidClickListener<T>{// 1. 集合的元素類型是Lambda，并且Lambda輸入參數的類型是 Tval actions = arrayListOf<(T)->Unit>()val actions2 = arrayListOf<(T?)->Unit>() // 可空// 2. 集合的元素類型為泛型val values = arrayListOf<T?>()// 3、設置監聽fun addListener(value:T?, lambda:(T?)->Unit){values += value // 運算符重載actions2 += lambda}// 4、通知觀察者fun notify(value:T?){val index = values.indexOf(value)actions2[index].invoke(value) // 執行方法actions2[index](value) // 執行方法二}// 5. 模擬點擊事件，通知所有觀察者fun touchListeners(){actions2.forEachIndexed{index, function ->  function(values[index])}}
}// 使用，測試val click = AndroidClickListener<String>()click.addListener("HaHa"){println("接收到數據：$it")}click.addListener("WCH"){println("$it 在吃飯中...")}click.addListener("Feather"){println("百萬博客主：$it")}click.touchListeners()// 函數引用版本fun method(value:String?){println(value)}click.addListener("Hello", ::method)

2、如何用變量接收類型中包含泛型的函數？

fun<T> method(value: T?):Unit{println(value)
}// 不可以用泛型
//    val error:(T?)->Unit = ::method// Any來代表T?val m1:(Any)->Unit = ::methodm1("Hello")// 具體類型也可以val m2:(Int)->Unit = ::methodm2(123)

自己實現Kotlin內置函數

1、forEach

// 定義
inline fun<E> Iterable<E>.mForEach(lambda:(E)->Unit){for(item in this)lambda(item)
}// 使用
listOf("AAA", "BBB", "CCC").mForEach{println(it)}

2、let和run，為什么會有this，為什么會有it

1. this，it
2. T.()->R, this是對T的匿名擴展函數，擁有this
3. (T)->R，it是參數類型，SAM單一抽象接口，函數式接口，it

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

3、thread

1. 注意點: corssinline

// 自己實現thread，特定lambda不能inline
inline fun thread(start:Boolean = true,name:String?=null,crossinline runAction:()->Unit // 限制不能inline，會copy大量代碼
):Thread{val thread = object:Thread(){override fun run() {super.run()runAction()}}if(start) thread.start() // name?.let { thread.name = it } // kotlin形式return thread
}

擴展函數原理

1、擴展函數就是構造static final方法，將對象作為返回值

class MyKt {}
fun MyKt.show() = println(this)

public final class MyKt {}
// 構造出Kt類，添加擴展函數名一樣的static final方法，將類的對象作為參數
public final class MyKtKt {public static final void show(@NotNull MyKt $this$show) {Intrinsics.checkNotNullParameter($this$show, "$this$show");System.out.println($this$show);}
}

2、思考：叫做擴展函數是否是因為沒有receiver？

companion object 原理 ==> 靜態內部類

1、為什么叫伴生對象？

1. 生成靜態內部類
2. 生成靜態成員變量（類變量）
3. 通過伴生對象實例，調用方法和獲取字段

2、使用處

class MyKt {companion object{fun show(){println(this)}val name = "wch"}
}fun main() {MyKt.show()MyKt.name
}

3、反編譯，生成源碼

1. 生成靜態內部類，Companion，并且有show()方法和字段name
2. 類中Companion實例，是static final變量
3. 像Java一樣調用類方法和獲取類屬性，本質通過Companion伴生對象，調用方法和get字段

public final class MyKt {private static final String name = "wch";public static final Companion Companion = new Companion((DefaultConstructorMarker)null);public static final class Companion {public final void show() {System.out.println(this);}public final String getName() {return MyKt.name;}private Companion() {}// $FF: synthetic methodpublic Companion(DefaultConstructorMarker $constructor_marker) {this();}}
}// 使用處
MyKt.Companion.show();
MyKt.Companion.getName();

函數式編程

Kotlin函數式編程

1. 鏈式調用
2. 非常豐富的函數庫
3. 模仿RxJava的響應式編程