[toc] # 高階函數 高階函數是將函數用作參數或返回值的函數,還可以把函數賦值給一個變數。 所有函數類型都有一個圓括弧括起來的參數類型列表以及一個返回類型:(A, B) -> C 表示接受類型分別為 A 與 B 兩個參數並返回一個 C 類型值的函數類型。 參數類型列表可以為空,如 () -> A ...
目錄
高階函數
高階函數是將函數用作參數或返回值的函數,還可以把函數賦值給一個變數。
所有函數類型都有一個圓括弧括起來的參數類型列表以及一個返回類型:(A, B) -> C 表示接受類型分別為 A 與 B 兩個參數並返回一個 C 類型值的函數類型。 參數類型列表可以為空,如 () -> A,Unit 返回類型不可省略。
(Int) -> String
函數類型表示法可以選擇性地包含函數的參數名:(x: Int, y: Int) -> Point。 這些名稱可用於表明參數的含義。
(Button, ClickEvent) -> Unit
如需將函數類型指定為可空,請使用圓括弧:((Int, Int) -> Int)?
fun a(funParam: (Int) -> String): String {
return funParam(1)
}
fun b(param: Int): String {
return param.toString()
}
調用
a(::b)
var d = ::b
b(1) // 調用函數
d(1) // 實際上會調用 d.invoke(1)
(::b)(1) // 用對象 :: b 後面加上括弧來實現 b() 的等價操作, 實際上會調用 (::b).invoke(1)
b.invoke(1) // 報錯
對象是不能加個括弧來調用的,但是函數類型的對象可以。為什麼?因為這其實是個假的調用,它是 Kotlin 的語法糖,實際上你對一個函數類型的對象加括弧、加參數,它真正調用的是這個對象的 invoke() 函數
雙冒號
:: 創建一個函數引用或者一個類引用
函數引用
fun isOdd(x: Int) = x % 2 != 0
我們可以很容易地直接調用它(isOdd(5)),但是我們也可以將其作為一個函數類型的值,例如將其傳給另一個函數。為此,我們使用 :: 操作符:
val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd))
這裡 ::isOdd 是函數類型 (Int) -> Boolean 的一個值。
如果我們需要使用類的成員函數或擴展函數,它需要是限定的,例如 String::toCharArray。
val args: Array<String> = arrayOf("1", "2")
args.filter(String::isNotEmpty)
class PdfPrinter {
fun println(any: Any) {
kotlin.io.println(any) //重名了可以用包名調用
}
}
val pdfPrinter = PdfPrinter()
args.forEach(pdfPrinter::println)
類引用
val c = MyClass::class
該引用是 KClass 類型的值
請註意,Kotlin 類引用與 Java 類引用不同。要獲得 Java 類引用, 請在 KClass 實例上使用 .java 屬性。
平時寫的類,其信息都可以在這個KClass來獲取
屬性引用
data class MediaItem(val title: String, val url: String)
var items= mutableListOf<MediaItem>()
items
.sortedBy { it.title }
.map { it.url }
.forEach { print(it) }
items
.sortedBy(MediaItem::title)
.map(MediaItem::url)
.forEach(::println)
匿名函數
沒有名字的函數
要傳一個函數類型的參數,或者把一個函數類型的對象賦值給變數,除了用雙冒號來拿現成的函數使用,你還可以直接把這個函數挪過來寫:
fun b(param: Int): String {
return param.toString()
}
a(fun b(param: Int): String {
return param.toString()
});
val d = fun b(param: Int): String {
return param.toString()
}
//名字沒意義,省略
a(fun(param: Int): String {
return param.toString()
});
val d = fun(param: Int): String {
return param.toString()
}
如果你在 Java 里設計一個回調的時候是這麼設計的:
public interface OnClickListener {
void onClick(View v);
}
public void setOnClickListener(OnClickListener listener) {
this.listener = listener;
}
使用的時候是這麼用的:
view.setOnClickListener(new OnClickListener() {
@Override
void onClick(View v) {
switchToNextPage();
}
});
kotlin寫法
fun setOnClickListener(onClick: (View) -> Unit) {
this.onClick = onClick
}
view.setOnClickListener(fun(v: View): Unit) {
switchToNextPage()
})
Lambda寫法:
view.setOnClickListener({ v: View ->
switchToNextPage()
})
Lambda 表達式
簡化匿名函數,代碼更簡潔
view.setOnClickListener({ v: View ->
switchToNextPage()
})
//如果 Lambda 是函數的最後一個參數,你可以把 Lambda 寫在括弧的外面:
view.setOnClickListener() { v: View ->
switchToNextPage()
}
//而如果 Lambda 是函數唯一的參數,你還可以直接把括弧去了:
view.setOnClickListener { v: View ->
switchToNextPage()
}
//另外,如果這個 Lambda 是單參數的,它的這個參數也省略掉不寫:
//根據上下文推導,根據最後一行代碼來推斷出返回值類型
view.setOnClickListener {
switchToNextPage()
}
Lambda 表達式的完整語法形式如下:
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
val sum = { x: Int, y: Int -> x + y }
多參數例子:
fold函數:將所提供的操作應用於集合元素並返回累積的結果
val items = listOf(1, 2, 3, 4, 5)
// Lambdas 表達式是花括弧括起來的代碼塊。
items.fold(0, {
// 如果一個 lambda 表達式有參數,前面是參數,後跟“->”
acc: Int, i: Int ->
print("acc = $acc, i = $i, ")
val result = acc + i
println("result = $result")
// lambda 表達式中的最後一個表達式是返回值:
result
})
// lambda 表達式的參數類型是可選的,如果能夠推斷出來的話:
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })
輸出:
acc = 0, i = 1, result = 1
acc = 1, i = 2, result = 3
acc = 3, i = 3, result = 6
acc = 6, i = 4, result = 10
acc = 10, i = 5, result = 15
joinedToString = Elements: 1 2 3 4 5
總結:
函數不能直接傳遞或者賦給某個變數,需要函數類型實例化,有三種方式:
使用已有聲明的可調用引用
1.函數引用
使用函數字面值的代碼塊
2.匿名函數
3.lambda 表達式
例子
實現介面
var onVideoStartCallBack: (() -> Unit)? = null
onVideoStartCallBack?.invoke()
videioView.onVideoStartCallBack = {
}
函數里實現介面
object UploaderListHelper {
fun startTaskUpload(activity: Activity, startCallBack: ((Int) -> Unit)?) {
startCallBack.invoke(position)
}
}
UploaderListHelper.startTaskUpload(activity) {
refreshProgress(it)
}
作用域函數
Kotlin 標準庫包含幾個函數,它們的唯一目的是在對象的上下文中執行代碼塊。當對一個對象調用這樣的函數並提供一個 lambda 表達式時,它會形成一個臨時作用域。在此作用域中,可以訪問該對象而無需其名稱。這些函數稱為作用域函數。共有以下五種:let、run、with、apply 以及 also。
這些函數基本上做了同樣的事情:在一個對象上執行一個代碼塊。不同的是這個對象在塊中如何使用,以及整個表達式的結果是什麼。
目的:簡潔
val person = findPerson();
//person是可null的,所以需要?
println(person?.age)
println(person?.name)
//上面太麻煩,findPerson加了?,所以後面不需要了,減少的判空操作。let可以安全調用
findPerson()?.let { person ->
person.work()
println(person.age)
}
//還可以更簡潔,person也不用寫
findPerson()?.apply {
work()
println(age)
}
使⽤時可以通過簡單的規則作出一些判斷
返回自身
返回值是它本身
從 apply 和 also 中選
作⽤域中使⽤ this 作為參數選擇 apply
val adam = Person("Adam").apply {
age = 32
city = "London"
}
println(adam)
作⽤域中使⽤ it 作為參數選擇 also
val numbers = mutableListOf("one", "two", "three")
numbers
.also { println("The list elements before adding new one: $it") }
.add("four")
with 非擴展函數
val numbers = mutableListOf("one", "two", "three")
with(numbers) {
println("'with' is called with argument $this")
println("It contains $size elements")
}
不需要返回自身
從 run 和 let 中選擇
作用域中使用 this 作為參數,選擇 run
作用域中使用 it 作為參數,選擇 let, 適合配合空判斷的時候
val service = MultiportService("https://example.kotlinlang.org", 80)
val result = service.run {
port = 8080
query(prepareRequest() + " to port $port")
}
// 同樣的代碼如果用 let() 函數來寫:
val letResult = service.let {
it.port = 8080
it.query(it.prepareRequest() + " to port ${it.port}")
}
it作為參數的好處
let 允許我們自定義參數名字,使可讀性更強,如果傾向可讀性可以選擇 T.let
參考文章
Kotlin 的高階函數、匿名函數和 Lambda 表達式
Kotlin官網