kotlin實戰(zhàn)教程之lambda編程

前言

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

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

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

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

lambda表達(dá)式的基本語法

下面是一個lambda表達(dá)式的基本語法:

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

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

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

可以把lambda表達(dá)式存儲在一個變量中，把這個變量當(dāng)做普通函數(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當(dāng)做一個函數(shù)傳遞個intOperator()作為參數(shù)。

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

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

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

比如下面這個例子

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

myPrint{
 print("a")
}

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

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

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

在這個代碼中使用了默認(rèn)參數(shù)使用it代替。在kotlin中，如果當(dāng)前上下文期望的是只有一個參數(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代碼一塊存儲。

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

成員引用

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

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

val sayQuote = Person::say

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

常用的庫函數(shù)

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

filter與map

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

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

map函數(shù)對集合中的每一個元素應(yīng)用給定的函數(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ù)量，不關(guān)心元素本身。

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

惰性集合操作 : 序列

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

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

我們要知道filter和map都會返回一個列表來保存結(jié)果，如果peoples這個集合元素非常多的話，那產(chǎn)生的這個中間集合就非常大，并且這個鏈?zhǔ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ā)的。

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

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

惰性集合.png

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

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

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

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

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

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

button.setOnClickListener{ //... }

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

lambda表達(dá)式的可重用性

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

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

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

 postponeComputation(1000, { print(42) })

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

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

在kotlin中，每個函數(shù)式接口的lambda都會被編譯成一個匿名類（除內(nèi)聯(lián)lambda)。如果lambda捕捉了變量，每個被捕捉的變量會在匿名內(nèi)部類中有對應(yīng)的字段，而且每次調(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標(biāo)準(zhǔn)庫中的函數(shù)。帶接受者是指：在lambda函數(shù)體可以調(diào)用一個不同對象的方法，而且無須借助任何額外限定符。

with

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

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帶來的運(yùn)行時開銷

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

修飾符標(biāo)記一個函數(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表達(dá)式會被直接替換到最終生成的代碼中，而不是被包含在一個實現(xiàn)了函數(shù)接口的匿名類中。

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

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

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

總結(jié)

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