前言

ambda即lambda表達式，簡稱lambda。本質(zhì)上是可以傳遞給其它函數(shù)的一小段代碼。有了lambda，可以輕松地把通用代碼結(jié)構(gòu)抽取成庫函數(shù)。lambda最常見的用途是和集合一起配合。kotlin甚至還擁有帶接收者的lambda，這是一種特殊的lambda。

本文是對<<kotlin實戰(zhàn)>>中 “l(fā)ambda編程”一章的總結(jié)，主要記錄了一些我認為比較重要的點

在kotlin中常見的lambda用法主要由以下幾種：

• 與集合一起使用
• lambda可以與任意java庫一起使用
• 帶接收者的lambda，比如with和apply

lambda表達式的基本語法

下面是一個lambda表達式的基本語法:

{ x:Int, y:Int -> x + y } 

lambda表達式始終用花括號包圍，實參并沒有用括號括起來。箭頭把實參列表和lambda的函數(shù)體隔開

lambda作為函數(shù)的參數(shù)傳遞

可以把lambda表達式存儲在一個變量中，把這個變量當做普通函數(shù)對待，也可以直接寫作函數(shù)參數(shù)，比如有一個intOperator函數(shù), 這個函數(shù)接收兩個int參數(shù)，和一個函數(shù)。

fun intOperator(o1: Int, o2: Int, run: (a: Int, b: Int) -> Int) {
 run(o1, o2)
}

val sumLambda = { x: Int, y: Int -> x + y }
intOperator(1, 2, sumLambda)
intOperator(1, 2, {x:Int, y:Int -> x + y})

上面可以看到，我們直接把lambda當做一個函數(shù)傳遞個intOperator()作為參數(shù)。

如果lambda表達式是函數(shù)調(diào)用的最后一個實參，它可以放到括號外邊:

intOperator(1, 2) { x: Int, y: Int -> x + y }

如果lambda表達式是函數(shù)的唯一實參時，還可以去掉調(diào)用代碼中的空括號對

比如下面這個例子

fun myPrint(lambda: () -> Unit) {
 lambda()
}

myPrint{
 print("a")
}

省略lambda參數(shù)類型并使用默認參數(shù)名稱

在kotlin中如果lambda參數(shù)的類型可以被推導出來，我們就不需要顯示聲明它，比如我們常用的庫函數(shù) map:

listOf("1", "2", "3").map{
 //
}

在這個代碼中使用了默認參數(shù)使用it代替。在kotlin中，如果當前上下文期望的是只有一個參數(shù)的lambda且這個參數(shù)的類型可以推斷出來，就會生成這個名稱。

允許在lambda內(nèi)部訪問非final變量甚至修改他們

在java中我們是知道的：匿名內(nèi)部類不能訪問非final變量，但在kotlin中可以:

fun main(args: Array<String>) {
 var count = 0
 listOf("1", "2", "3").forEach{
 count++
 }
 print(count)
}

其實對于kotlin來說，如果在lambad中引用非final變量，它的值會被封裝起來，并且會和lambda代碼一塊存儲。

當然對于異步代碼或者事件響應回調(diào)這個是無效的。

成員引用

在上面我們知道可以直接把lambda當做函數(shù)的參數(shù)傳遞給一個函數(shù)，但是如果當做參數(shù)傳遞的代碼已經(jīng)被定義成了函數(shù)那怎么辦呢？

在kotlin中可以使用::把函數(shù)轉(zhuǎn)換成一個值，從而傳遞給函數(shù)。這里比如有一個Person類，他有一個say函數(shù)，我們可以這樣獲得這個函數(shù)的引用：

val sayQuote = Person::say

這種表達式叫做成員引用，對于頂層函數(shù)可以直接 ::say,來獲得這個函數(shù)的引用。

常用的庫函數(shù)

對于集合，kotlin提供了豐富的庫函數(shù)便于我們使用，對于這些函數(shù)這里我們只介紹一些關鍵點。

filter與map

filter函數(shù)會遍歷集合并選出應用給定lambda后會返回true的那些元素, 需要注意的是，返回的是一個新的集合

val newList = listOf(1, 2, 3, 4).filter{ it % 2 == 0}

map函數(shù)對集合中的每一個元素應用給定的函數(shù)并把結(jié)果收集到一個新集合中

val newList = listOf(1, 2, 3, 4).map{ it.toSting() }

all、any、count、find

• all與any用來檢查集合中的所有元素是否都符合某個條件， all表示全部 && any表示至少有一個
• count函數(shù)檢查有多少個元素滿足判斷式
• find函數(shù)返回第一個符合條件的元素

count 與 size

在一些情況下使用count要高效于size， 比如統(tǒng)計集合中有多少個偶數(shù):

listOf(1, 2, 3, 4, 5).count({it % 2 == 0})
listOf(1, 2, 3, 4, 5).filter({it % 2 == 0}).size

上面兩種做法都可以實現(xiàn)這個需求，不過filter會創(chuàng)建一個新的集合，而 count方法只會跟蹤匹配元素的數(shù)量，不關心元素本身。

其他還有 groupBy/flatMap/flatten，這里不細講了。

惰性集合操作 : 序列

在說什么是惰性集合操作之前，我們先來看一下非惰性集合操作map與filter, 以獲取姓名為A開頭的人的名字為例:

peoples.map{it.name}.filter{it.startWith("A")}

我們要知道filter和map都會返回一個列表來保存結(jié)果，如果peoples這個集合元素非常多的話，那產(chǎn)生的這個中間集合就非常大，并且這個鏈式調(diào)用會非常低效。

為了解決這個問題kotlin引入了 惰性集合:序列, 序列中的元素的求值是惰性的，不需要創(chuàng)建集合來保存中間結(jié)果，我們可以使用序列來解決上面的問題:

peoples.asSequence().map{it.name}.filter{it.startWith("A")}.toList()

序列的操作

序列的操作分為兩類：中間和末端操作, 以上面那個例子為例:

peoples.asSequence().map{it.name}.filter{it.startWith("A")}.toList()

map、filter都是中間操作，toList為末端操作。一次中間操作返回的是另一個序列，這個新序列知道如何變換原始序列中的元素，而一次末端操作返回的是一個結(jié)果，這個結(jié)果可能是集合、元素、數(shù)字等。

序列中中間操作的計算都是由末端操作觸發(fā)的。

我們可以使用擴展函數(shù)asSequence把任意集合轉(zhuǎn)換成序列，調(diào)用toList來做反向轉(zhuǎn)換

我們來對比一下上面兩種方法:

惰性集合.png

可以看到，使用序列會明顯比直接使用map和filter來完成這個任務效率更高

• 對原集合只會進行一次遍歷
• 只會生成一個結(jié)果集合
• 對于混合有any這種集合操作，序列可以明顯提高性能。

注意對于混合map/filter，這種操作時，如果被操作集合比較小，是不需要使用序列的。至于序列如何手動創(chuàng)建，這里不做細究

kotlin與Java函數(shù)式接口

函數(shù)式接口是指帶有一個抽象方法的接口，在java api中比如Runnable、Callable等

我們在實際使用kotlin時，可能大部分API還是java API，但是kotlin的lambda可以無縫地和javaAPI互操作，比如給一個button設置onclick事件:

button.setOnClickListener{ //... }

這個操作在java8之前我們不得不通過創(chuàng)建一個匿名內(nèi)部類來實現(xiàn)。

lambda表達式的可重用性

比如有一個函數(shù)postponeComputation()，接收一個函數(shù)，并循環(huán)執(zhí)行這個函數(shù)指定次數(shù):

postponeComputation(1000, object:Runnable{
 override fun run(){
 print(42)
 }
})

當你顯示聲明這個參數(shù)對象時，每次調(diào)用都會創(chuàng)建一個新的實例，而使用lambda情況不同:如果lambda沒有訪問任何來自自定義它的函數(shù)的變量，相應的匿名類實例可以在多次調(diào)用中重用:

 postponeComputation(1000, { print(42) })

但是如果lambda從包圍它的作用域中捕捉了變量，每次調(diào)用就不再可能重用同一個實例了。 至于為什么將會在 Lambda的實現(xiàn)細節(jié)的講到。

Lambda的實現(xiàn)細節(jié)

在kotlin中，每個函數(shù)式接口的lambda都會被編譯成一個匿名類（除內(nèi)聯(lián)lambda)。如果lambda捕捉了變量，每個被捕捉的變量會在匿名內(nèi)部類中有對應的字段，而且每次調(diào)用這個lambda都會創(chuàng)建一個這個匿名內(nèi)部類的實例。如果沒有捕捉變量，就會創(chuàng)建一個單例的類。

編譯后的匿名內(nèi)部類的名稱由lambda聲明所在的函數(shù)名稱加上后綴衍生出來的,比如下面這個lambda:

class Person{
 fun test(){
 a.setRunnable({
  print("a")
 })
 }
}

這個lambda會被編譯成:

class Person$1:Runnable{
 override fun run(){
 print("a")
 }
}

lambda與函數(shù)式接口的轉(zhuǎn)換

有些時候我們需要函數(shù)式接口的實例，比如一個方法返回的是一個函數(shù)式接口，這時候就不能直接返回一個lambda了:

fun getRunnable():Runnable{}

這時候如果直接這樣寫就會報錯 : fun getRunnable() = { } ,這是因為編譯器不會智能轉(zhuǎn)換，不過kotlin提供了 函數(shù)式接口構(gòu)造方法來使操作更方便:

fun getRunnable() = Runnable{ }

Runnable{}是編譯器生成的方法，等同于使用匿名對象的方式。

帶接收者的lambda: with 與 apply

這兩個函數(shù)式kotlin標準庫中的函數(shù)。帶接受者是指：在lambda函數(shù)體可以調(diào)用一個不同對象的方法，而且無須借助任何額外限定符。

with

with是一個接收兩個參數(shù)的函數(shù)，一個參數(shù)是 被接收者， 它會被傳給第二個參數(shù) lambda表達式 ， 在lambda表達式著呢個我們可以不用任何限定符直接訪問這個值的方法和屬性

fun alphabet():String{
 val stringBuilder = StringBuilder()
 return with(stringBuilder){
 for(letter in 'A'..'Z'){
  append(letter) //也可以使用this.append()
 }
 toString()
 }
}

with的返回值是執(zhí)行了lambda代碼的結(jié)果

apply

apply與with的唯一區(qū)別是它始終返回接收者對象。上面的函數(shù)我們可以這樣改寫：

fun alphabet() = StringBuilder().apply{
 for(letter in 'A'..'Z'){
 append(letter) //也可以使用this.append()
 }
}.toString()

內(nèi)聯(lián)函數(shù):消除Lambda帶來的運行時開銷

上面我們已經(jīng)知道，lambda表達式會被正常地編譯成匿名類，這表示每調(diào)用一次lambda表達式，一個額外的類就會被創(chuàng)建，為了解決這個運行時性能的開銷，kotlin提供了inline修飾符，如果使用inline

修飾符標記一個函數(shù)，在函數(shù)被使用的時候編譯器并不會生成函數(shù)調(diào)用的代碼，而是使用函數(shù)實現(xiàn)的真實代碼替換每一次的函數(shù)調(diào)用。

先來舉一個例子:

inline fun test(action:()->T){
 action()
}

fun foo(){
 test{
 print("a")
 }
}

foo()實際會被編譯為下面的代碼:

fun foo_(){
 print("a")
}

從上面這個例子可以看出，作為參數(shù)的lambda表達式會被直接替換到最終生成的代碼中，而不是被包含在一個實現(xiàn)了函數(shù)接口的匿名類中。

注意如果lambda參數(shù)在某個地方被保存起來，以便后面可以繼續(xù)使用，這種lambda表達式將不會被內(nèi)聯(lián)，因為必須要有一個包含這些代碼的對象存在

內(nèi)聯(lián)的集合操作

kotlin標準庫中的map、filter等大部分函數(shù)都是內(nèi)聯(lián)函數(shù)，因此使用標準庫函數(shù)不需要擔心性能開銷。

總結(jié)

以上就是這篇文章的全部內(nèi)容了，希望本文的內(nèi)容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。