前语：一件事无论太晚或许太早，都不会阻止你成为你想要成为的那个人。 ——《本杰明巴顿奇事》
前语
今日咱们来聊下 lambda 表达式。lambda 表达式应该都不陌生，在 Java8 中引进一个很重要的特性，将开发者从原来繁琐的语法中解放出来，可是局限于只要 Java8 版别才能运用。而 Kotlin 弥补了这一问题，Kotlin 中的 lambda 表达式与 Java 混合编程能够支撑 Java8 以下的版别。
为什么运用 Kotlin 的 Lambda 表达式
针对 Kotlin 中运用 lambda 表达式的问题，主要有一下几点优点：
- Kotlin 的 lambda 表达式愈加简练易懂的语法完成功用，使开发者从原有冗余烦琐的语法声明中解放出来。能够运用函数式编程中的过滤、映射、转化等操作符处理调集数据，从而使你的代码愈加挨近函数式编程的风格。
- Java8 以下的版别不支撑 lambda 表达式，而 Kotlin 则兼容 Java8 以下版别有很好的互操作性，十分合适 Java8 以下版别与 Kotlin 混合开发的模式，解决 Java8 以下版别不能运用 lambda 表达是瓶颈。
- 在 Java8 版别运用 lambda 表达式是有约束的，它不是真实意义上的闭包，而 Kotlin 中的 lambda 才是真实意义上支撑闭包的完成。（下面会论述）
Kotlin 函数是一级函数，这意味着它们能够存储在变量和数据结构中，作为参数传递给其他高阶函数，也能够从其他高阶函数回来。关于其他非函数值，你能够以任何可能的办法对函数进行操作。
为了完成这一点，作为一种静态类型编程言语，Kotlin 运用一系列函数类型来标明函数，并供给了一组专门的言语结构，比方 lambda 表达式。
一、高阶函数
高阶函数是指接纳函数作为参数（或回来函数）的函数。即一个函数能够将另一个函数当作参数（或回来函数），将其他函数用作参数（或回来函数）的函数被称为“高阶函数”。
（1）下面是一个高阶函数的示例：
fun stringMapper(str: String, mapper: (String) -> Int): Int {
// Invoke function
return mapper(str)
}
stringMapper() 函数的参数是一个 String 以及一个函数，这个参数是将依据你传递给它的 String 来推导 Int 值。
要调用 stringMapper()，能够传递一个 String 和一个满意第二个参数条件的函数（即一个将 String 当作输入并输出 Int 的函数），如下示例：
stringMapper("Android", { input ->
input.length
})
假如匿名函数是在某个函数上界说的最终一个参数，则你能够在用于调用该函数的圆括号 () 之外传递这个参数，如下所示：
stringMapper("Android") { input ->
input.length
}
（2）另一个很好的比如便是针对调集的 函数式编程习语折叠，它接受一个初始的累加器值和一个组合函数，并经过连续地将当时的累加器值与每个调集元素组合来构建它的回来值，替换这个叠加器：
//从[初始]值开端累加值，从左到右对当时累加器值和每个元素运用[操作]
fun <T, R> Collection<T>.fold(
initial: R,
combine: (acc: R, nextElement: T) -> R
): R {
var accumulator = initial
for (element: T in this) {
accumulator = combine(accumulator, element)
}
return accumulator
}
在上面的代码中，参数 combine 有一个函数类型 (R, T) -> R ，因而它接纳一个函数，该函数接纳两个参数类型 R 和 T，并回来一个类型 R 的值。它在 for 循环中调用，然后将回来值分配给 accumulator。
调用 fold，咱们需求给它传递一个函数类型的实例作为参数，lambda表达式（在下面描绘的更详细）在高阶函数调用站点被广泛用于这种状况：
val items = arrayOf(1, 2, 3, 4, 5)
//Lambdas是大括号括起来的代码块
items.fold(0, { acc: Int, i: Int -> //当lambda 有参数时，参数在前面，然后是 `->` 符号
print("acc == $acc | i == $i | ")
val result = acc + i
println("result == $result")
//假如不显式指定，lambda 中的最终一个表达式被认定为是回来值
result
})
//参数类型在lambda中假如能主动揣度则能够省掉
val itemsStr = items.fold("Elements:", { acc, i -> acc + "" + i })
//函数引证也能够用于高阶函数调用
val products = items.fold(1, Int::times)
打印数据如下：
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
1.1 函数类型
Kotlin 运用一系列函数类型，比方 (Int) -> String 来声明函数：val onClick: () -> Unit = ...。这些类型有一个特别的符号，对应函数的签名，即它们的参数和回来值：
-
(A, B) -> C： 一切的函数类型有一个带括号的参数类型列表和一个回来类型。(A, B) -> C标明一个函数类型，该类型标明具有类型 A 和 B 的两个参数并回来类型 C 的值的函数。参数类型列表能够是空的，如() -> A。不能省掉Unit回来类型； -
A.(B) -> C： 函数类型能够有一个附加的接纳类型，它在点符号.之前指定。类型A.(B) -> C标明能够在接纳目标 A 调用 B 类型的参数，回来值为 C 类型的函数。带有接纳器的函数文字通常与这些类型一同运用； - 挂起函数 ： 挂起函数特点特性类型的函数，在标明法中有一个挂起润饰符。例如：
suspend () -> Unit或许suspend A.(B) -> C。
函数类型标明法能够挑选包括函数参数的称号：(x: Int, y: Int) -> Point。这些称号可用于记载参数的意义。
1.要指定一个函数类型能够为空，能够运用括号：
((Int, Int) -> Int)?2.函数类型能够运用括号组合：
(Int) -> ((Int) -> Unit)3.箭头符号
->是右结合的，(Int) -> (Int) -> Unit与(Int) -> ((Int) -> Unit)标明同一个类型，可是与函数类型((Int) -> (Int)) -> Unit不同。
你也能够运用类型别号给一个函数类型一个代替称号：
typealias ClickHandler = (Button, ClickEvent) -> Unit
1.2 实例化函数类型
下面有几种办法能够获得一个函数类型的实例：
（1）在函数文字中运用代码块，办法如下：
- 一个 lambda 表达式：
{ a, b -> a + b }； - 一个匿名函数：
fun(s: String): Int { return s.toIntOrNull() ?: 0 }。
带有 receiver 的函数文本能够用作带有 receiver 的函数类型的值。
（2）运用完成函数类型作为接口的自界说类的实例：
//界说IntTransformer类型，完成了 (Int) -> Int 接口
class IntTransformer : (Int) -> Int {
override operator fun invoke(num: Int): Int = TODO()
}
val intFunction: (Int) -> Int = IntTransformer()
假如数据满足明亮，编译器能够揣度出变量的函数类型：
val result = { i: Int -> i * 2 }//揣度出的类型是(Int) -> Int
关于包括 receiver 的办法类型，假如 receiver 的类型以及该办法类型的剩余参数类型和没有显式界说 receiver 的办法类型的入参相匹配，则二者能够进行相护赋值。比方办法类型 String.(Int) -> Boolean 便是显式包括 receiver 的办法类型，该 receiver 的办法类型是 String，参数类型是 Int，所以等同于办法类型 (String, Int) -> Boolean，这个办法类型接纳一个 String 类型和一个 Int 类型参数，而第一个 String 类型刚好和 receiver 相匹配，剩余的参数类型也彼此匹配，能够以为它们是相等的。
//String，Int传入的参数类型后边的String标明回来值类型，times标明Int类型参数
val substringStr: String.(Int) -> String = { times ->
this.substring(0, times)//times为5
}
val twoParameters: (String, Int) -> String = substringStr
//(A, B) -> C 一切的函数类型有一个带括号的参数类型列表和一个回来类型,
//标明一个类型，该类型标明具有类型 A 和 B 的两个参数并回来类型 C 的值的函数。
fun runTransformation(ss: (String, Int) -> String): String {
return ss("Android", 5)
}
val trans = runTransformation(substringStr) //substringStr()函数作为参数传递给runTransformation()函数
打印数据如下：
Andro
留意：没有接纳方的函数类型在默许状况下会被主动揣度出来，即便运用扩展函数的引证初始化变量也是如此。假如要更改，请显式指定变量类型。
1.3 调用函数类型实例
函数类型的值能够经过运用其 invoke(...) 操作符来调用：f.invoke(x) 或许 f(x)。invoke() 标明经过 函数变量 调用自身。
假如值具有 receiver 类型，则 receiver 目标应作为第一个参数传递。用 receiver 调用函数类型的值的另一种办法是在它前面加上 receiver 目标，就好像这个值是一个扩展函数：1.foo(2)。
//String.plus()经过将该字符串与给定的其他目标的字符串标明办法链接起来而获得的字符串
val stringPlus: (String, String) -> String = String::plus
val intPlus: Int.(Int) -> Int = Int::plus //Int.plus()将另一个值增加到此值
val str = stringPlus.invoke("<-", "->") //打印：<-->
val str2 = stringPlus("Hello", "World") //打印：HelloWorld
val int1 = intPlus(1, 1) //打印：2
val int2 = intPlus.invoke(2, 3) //打印：5
val int3 = 4.intPlus(5) //打印：9
二、Lambda表达式
Lambda 表达式实质其实是匿名函数，由于底层的完成还是匿名函数来完成的，可是咱们在运用的时分其实不太需求关怀底层是怎么完成的，Lambda 的呈现的确削减了代码量的编写，变得愈加简练。
Lambda 表达式和匿名函数都是“字面函数”，也便是说，在没有显式界说办法的时分，能够经过这种办法生成一个具有同等办法，功用的办法。
strMax(strings, { a, b -> a.length > b.length })
函数 strMax() 是一个高阶函数，它采用函数值作为第二个参数。第二个参数是一个表达式 { a, b -> a.length > b.length }，它自身是一个函数，即一个函数字面量，它等价于下面的命名函数：
fun compare(a: String, b: String): Boolean = a.length < b.length
2.1 Lambda表达式分类
在 Kotlin 中实践能够将 lambda 表达式分为两大类，一个是一般的 lambda 表达式，另一个是带接纳者的 lambda 表达式，两种表达式在运用和运用场景也是有很大的不同。先看下两种 lambda 表达式的类型声明：
@kotlin.internal.InlineOnly
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
@kotlin.internal.InlineOnly
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
看到上面 lambda 表达式的分类，你有没有想到之前的扩展函数：
2.2 Lambda表达式语法
lambda 表达式的规范办法根本声明满意三个条件：
- 1、含实践参数；
- 2、含函数体（假如函数体为空也要声明出来）；
- 3、以上内容有必要被包括在大括号内。
以上是 lambda 表达式最规范的办法，可能这种规范办法今后在日常开发中很少看见，更多是愈加简化的办法。（下面会介绍 lambda 表达式简化的规则）
lambda表达式完好句语法办法如下：
//显式界说sum的类型为(Int, Int) -> Int的函数类型
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
lambda 表达式总是在大括号 {} 包裹着，完好语法办法的参数声明在大括号内，并有能够省掉的参数类型，body 在 -> 符号之后。假如 lambda 的揣度回来类型不是 Unit，则 lambda 主体内的最终一个（或许可能是单个）表达式将被默许视为回来值。
//也能够给sum直接赋值一个函数类型实例，等于后边的lambda表达式
val sum = { x: Int, y: Int -> x + y }
假如咱们去掉一切可选的参数类型: (Int, Int) -> Int ，编译器能主动揣度，简化后便是上面的款式。
表达式类型
() -> Unit //标明无参数无回来值的Lambda表达式类型
(T) -> Unit //标明接纳一个T类型参数，无回来值的Lambda表达式类型
(T) -> R //标明接纳一个T类型参数，回来一个R类型值的Lambda表达式类型
(T, P) -> R //标明接纳一个T类型和P类型的参数，回来一个R类型值的Lambda表达式类型
(T, (P, Q) -> S) -> R //标明接纳一个T类型参数和一个接纳P、Q类型两个参数并回来一个S类型的值的Lambda表达式类型参数，回来一个R类型值的Lambda表达式类型
前面的几种状况比较好了解，最终一种有点难度，最终一种实践上属于高阶函数的领域，这种类型有点像剥洋葱那样层层往内拆分，便是由外往内看，层层拆分，关于自身是一个 lambda 表达式类型的，先暂时看做一个全体，然后就能够确认最外层的 lambda 类型，如此类推往内部拆分。
语法格局：
val/var <变量名> = { …… }
事例：
//源码
fun noParameter() {
println("无参数lambda")
}
//lambda表达式
val noParameter = { println("无参数lambda") }
//调用
fun main(args: Array<String>) {
noParameter()
}
lambda表达式总是被大括号包括着。
（2）有参数语法
语法格局：
val/var <变量名> : (<参数类型>，<参数类型>，...) -> 回来值类型 = { 参数，参数，... -> 操作参数的代码 }
//等价于：
val/var <变量名> = { 参数:<参数类型>，参数:<参数类型>，... -> 操作参数的代码 }
事例：
//源码
fun hasParameter(a: Int, b: Int): Int {
return a + b
}
//lambda表达式
val hasParameter: (Int, Int) -> Int = { a, b -> a + b }
//简化后
val hasParameter2 = { a: Int, b: Int -> a + b }
//调用
fun main(args: Array<String>) {
hasParameter(4, 2)//打印 6
}
完好的 lambda 表达式如上述所示，它有完好的参数类型和表达式回来值，能够把一些类型标示省掉的时分（如 hasParameter2 ），当揣度出来的回来值类型不为 Unit 时，它的回来值即为 -> 后边代码的最终一个表达式的类型。（lambda回来值下面会讲到）
（3）lambda表达式作为函数中的参数时
语法格局：
fun test(arg : Int, <参数名> : (参数 : 类型, 参数 : 类型, ... ) -> 表达式回来类型) {
//TODO
}
事例：
//源码
fun expressionParameter(numA: Int, numB: Int): Int {
}
//lambda表达式，numB只供给了参数类型和回来类型，调用时需求写出它
fun expressionParameter(numA: Int, numB: (a: Int, b: Int) -> Int): Int {
return numA * numB.invoke(3, 4) //a * ( 3 + 4 )，`invoke()` 标明经过 `函数变量` 调用自身。
}
//lambda表达式，这儿作为上面函数的参数运用
val expression: (Int, Int) -> Int = { a, b -> a + b }
//调用
fun main(args: Array<String>) {
//第二个参数需求写出它的详细完成
expressionParameter(2, expression)//打印为 14
}
上述状况标明为高阶函数，当 lambda 表达式作为一个参数时，只为其表达式供给了参数类型和回来类型，所以在调用高阶函数的时分要写出该表达式的详细完成。
expressionParameter(numA: Int, numB: (a: Int, b: Int) -> Int) 中参数 numB 只供给了参数类型和回来类型，调用时需求写出参数 numB 的详细完成 { a, b -> a + b }。
2.3 lambdas 语法简化转化
lambda表达式能够大大简化代码写法，也能削减不必要的办法界说，可是带来的副作用是代码的可读性大大下降。下面来介绍一下lambda表达式简化的几种办法，以下面的比如为例：
//check标明传入一个Int类型参数，回来一个Boolean类型回来值
fun getResult(a: Int, check: (Int) -> Boolean): String {
val result = if (check(a)) "Android" else "null"
return result
}
//调用上面的函数
getResult(10, { num: Int -> num > 0 })
第二个参数 { num: Int -> num > 0 } 契合 check: (Int) -> Boolean 函数类型，表达式用 {} 包裹，num 为该表达式传入的参数， -> 符号之后是需求操作的代码。
（1）假如一个函数的最终一个参数是一个函数，那么作为对应参数传递的 lambda 表达式能够放在圆括号 () 外：
//getResult()函数的最终一个参数{ num: Int -> num > 0 }被说到函数括号外面
getResult(10) { num: Int -> num > 0 }
这种语法也称为跟随 lambda。
（2）假如 lambda 是被调用的函数的仅有一个参数，函数的圆括号 () 能够被彻底省掉：
//只要一个参数
fun getResult(check: (Int) -> Boolean) {
}
//简化前
getResult() { num: Int -> num > 0 }
//简化后，{ num: Int -> num > 0 }是setText函数的仅有一个参数，被说到圆括号外面而且圆括号能够被省掉
getResult { num: Int -> num > 0 }
（3） it 单个参数的隐式称号
在高阶函数中，假如 lambda 表达式的参数只要一个，那么不答应声明仅有的参数而且省掉了 -> 符号，用 it 标明这个参数的称号。
//简化前
getResult(10) { num: Int -> num > 0 }
//简化后，it标明参数称号，即num
getResult(10) {
it > 0
}
it 不是关键字，标明单个参数的隐式称号。
今后开发中咱们更多的是运用简化版的 lambda 表达式，由于规范版的 lambda 表达式还是有点烦琐，比方实参类型就能够省掉，Kotlin 支撑依据上下文智能推导出类型，所以能够省掉，摒弃烦琐的语法，下面总结了一下：
it 这种，一般在多个 lambda 嵌套时不主张运用，大大下降代码可读性，最终连开发者都不知道 it 代表什么。
（4）比如
这个是 Kotlin 库中的 joinToString 扩展函数，最终一个参数是一个 接纳一个调集类型T的参数回来一个CharSequence类型的 lambda 表达式。
//joinToString内部声明
public fun <T> Array<out T>.joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null): String {
return joinTo(StringBuilder(), separator, prefix, postfix, limit, truncated, transform).toString()
}
//调用
fun main(args: Array<String>) {
val items = arrayOf(1, 2, 3, 4, 5)
items.joinToString(separator = ",", prefix = "<", postfix = ">") {
return@joinToString "index$it"
}
}
能够看到 joinToString 调用的当地运用了 lambda 表达式作为参数的简化办法，将它从括号 () 中提出来了。这个的确给调用带来了一点小疑惑，由于并没有显式标明 lambda 表达式运用到哪里，所以不熟悉内部完成的开发者很难了解，关于这种问题，Kotlin 实践上供给了解决办法，也便是命名参数：
//调用
fun main(args: Array<String>) {
val items = arrayOf(1, 2, 3, 4, 5)
items.joinToString(separator = ",", prefix = "<", postfix = ">", transform = { "index$it" })
}
2.4 从lambda表达式回来值
假如 lambda 表达式有回来值，则 lambda 主体内的最终一行表达式将被视为回来值回来，即lambda会将最终一条语句作为其回来值。假如运用约束的回来语法显式地从 lambda 回来一个值，则不会再以默许的最终一行回来值。
下面两种标明办法是等价的：
//check标明传入一个Int类型参数，回来一个Boolean类型回来值
fun getResult(a: Int, check: (Int) -> Boolean): String {
val result = if (check(a)) "Android" else "null"
return result
}
//调用
getResult(10) {//it 标明参数称号
val result = it > 0
result //lambda 表达式默许最终一行为回来值
}
val apple = getResult(10) {
val result = it > 0
return@getResult result //约束的回来语法指定回来值，这儿直接回来了true
false //上面运用了约束的回来语法指定回来值，不再以默许最终一行为回来值
}
println("getResult == $apple") //打印 getResult == Android
这个习惯，连在括号外传递一个 lambda 表达式，答应链式风格的代码：
val strs = arrayOf("sum", "java", "android", "kotlin")
strs.filter { it.length == 5 }.sortedBy { it }.map { it.toUpperCase() }
2.5 下划线用于未运用的变量（自1.1以来）
假如 lambda 参数未运用，你能够用下划线 _ 来代替参数的称号：
//假如参数未运用，用下划线 `_` 来代替它的称号
val radioGroup = RadioGroup(this)
//原型
radioGroup.setOnCheckedChangeListener { group, checkedId ->
}
//简化后，参数group未被运用，用下划线 `_` 来代替
if (checkedId == 0) {
//TODO
}
}
下划线 _ 标明未运用的参数，不处理这个参数。
2.6 运用typealias关键字给Lambda类型命名
咱们试想一个场景便是可能会用到多个 Lambda表达式，可是这些 Lambda表达式的类型许多相同，咱们就很简单把一大堆的Lambda类型重复声明或许Lambda类型声明太长不利于阅览。实践上不需求，Kotlin 对立一切烦琐语法，它都会给你供给一系列的解决办法，让你简化代码的一同又不下降代码的可读性。
fun main(args: Array<String>) {
val strEmpty: (String) -> Unit = {
if (it.isEmpty()) {
//TODO
}
}
val strTrue: (String) -> Unit = {
if (it.equals("true")) {
//TODO
}
}
}
运用 typealias 关键字声明 (String) -> Unit 类型：
typealias StringEmpty = (String) -> Unit //在最顶层
fun main(args: Array<String>) {
val strEmpty: StringEmpty = {
if (it.isEmpty()) {
//TODO
}
}
val strTrue: StringEmpty = {
if (it.equals("true")) {
//TODO
}
}
}
三、Lambda表达式常用场景
3.1 场景一：
lambda 表达式与调集一同运用是最常见的场景，能够各种帅选、映射、改换操作符和对调集数据进行各种操作，十分灵敏，相似运用 RxJava 函数式编程，Kotlin 在言语层面无需增加额外库，就给你供给函数式编程API。
val lists = arrayListOf("Java", "Android", "Kotlin")
lists.filter {
it.startsWith("K")
}.map {
"$it 是一门十分好的言语！"
}.forEach {
println(it)//Kotlin 是一门十分好的言语！
}
3.2 场景二：
代替原有匿名内部类，可是留意只能代替单笼统办法的类。
tv.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//TODO
}
});
用 Kotlin lambda 完成，等价于：
textView.setOnClickListener {
//TODO
}
3.3 场景三：
界说 Kotlin 扩展函数或许说需求把某个操作或许函数当作值传入某个函数的时分。
fun showDialog(content: String = "弹框", negativeText: String = "撤销", positiveText: String = "确认", negativeAction: (() -> Unit)? = null, positiveAction: (() -> Unit)? = null) {
AlertDialog.Builder(this)
.setMessage(content)
.setNegativeButton(negativeText) { _, _ ->
negativeAction?.invoke()
}
.setPositiveButton(positiveText) { _, _ ->
positiveAction?.invoke()
}
.setCancelable(true)
.create()
.show()
}
四、Lambda表达式的作用域中拜访变量
4.1 Kotlin和Java拜访局部变量的差异
（1）在 Java 函数内部界说一个匿名内部类或许 lambda，内部类拜访的局部变量有必要是 final 润饰的，意味着在内部类内部或许 lambda 表达式的内部无法修正函数局部变量的值。
//Java
public class ExampleActivity extends AppCompatActivity implements View.OnClickListener {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_example);
final int count = 0;//需求运用final润饰
findViewById(R.id.btn_syn).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
System.out.println(count);//在匿名OnClickListener内部类拜访count有必要要是final润饰的
}
});
}
（2）Kotlin 中在函数界说的内部类或 lambda，既能够拜访 final 润饰的变量，也能够拜访非 final 润饰的变量，意味着 lambda 内部是能够直接修正函数局部变量的值。
class LambdasActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val textView = TextView(this)
var count = 0//声明非final类型
val countFinal = 0//声明final类型
textView.setOnClickListener {
println(count++)//拜访并修正非final润饰的变量
println(countFinal)//拜访final润饰的变量，和Java相同
}
}
}
经过以上对比发现，Kotlin 运用 lambda 比 Java 中运用 lambda 更灵敏，拜访约束更少。Kotlin 中的 lambda 表达式是真实意义上支撑闭包，而 Java 中的 lambda 则不是。下面来剖析 Kotlin 是怎么做到这一点的？
4.2 Kotlin中Lambda表达式的变量捕获以及原理
什么是变量捕获？
经过上面的比如，咱们知道在 Kotlin 中既能拜访 final 润饰的变量也能拜访和修正非 final 润饰的变量。这儿涉及到一个概念lambda表达式的变量捕获，实践上便是 lambda 表达式在函数体内能够拜访和修正外部变量，咱们就称为这些变量被 lambda 表达式捕获了。
有了这个概念咱们把上面的总结一下：
- 1、在 Java 中 lambda 表达式只能捕获
final润饰的变量； - 2、在 Kotlin 中 lambda 表达式既能捕获
final润饰的变量也能拜访和修正非final润饰的变量。
变量捕获的原理
咱们知道函数局部生命周期特点这个函数，当函数履行结束，局部变量也被销毁了，可是假如这局部变量被 lambda 捕获了，那么运用这个局部变量的代码将被存储起来等待稍后再次履行，也便是被捕获的变量能够延迟生命周期的。
- 1、lambda 捕获
final润饰的局部变量原理： 局部变量的值和运用这个变量的表达式被存储起来； - 2、lambda 捕获非
final润饰的局部变量原理： 实践是 lambda 表达式还是只能捕获final润饰的变量，而为什么 Kotlin 能做到修正非final变量的值，Kotlin 在语层面做了桥接包装，它把非final润饰的变量运用一个 Ref 包装类包装起来，然后外部保存 Ref 包装类的引证是final的，然后表达式和这个final润饰的 Ref 引证一同存储，随后在 lambda 内部修正变量的值实践上是经过这个final的 Ref 包装类引证去修正的。
final 局部变量的反编译成的 Java 代码：
class LambdasActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
val textView = TextView(this)
var count = 0//声明非final类型
textView.setOnClickListener {
println(count++)//拜访并修正非final润饰的变量
}
}
}
反编译后：
操作：Android studio > Tools > Kotlin > Show Kotlin Bytecode > 点击 Decompile > Kotlin类即可反编译成 Java类
@Metadata(
mv = {1, 1, 18},
bv = {1, 0, 3},
k = 1,
d1 = {"\u0000\u0018\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0002\n\u0002\u0010\u0002\n\u0000\n\u0002\u0018\u0002\n\u0000\u0018\u00002\u00020\u0001B\u0005\u0006\u0002\u0010\u0002J\u0012\u0010\u0003\u001a\u00020\u00042\b\u0010\u0005\u001a\u0004\u0018\u00010\u0006H\u0014\u0006\u0007"},
d2 = {"Lcom/suming/kotlindemo/blog/LambdasActivity;", "Landroidx/appcompat/app/AppCompatActivity;", "()V", "onCreate", "", "savedInstanceState", "Landroid/os/Bundle;", "app"}
)
public final class LambdasActivity extends AppCompatActivity {
private HashMap _$_findViewCache;
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView textView = new TextView((Context)this);
final IntRef count = new IntRef();//IntRef特别的包装器类型，final润饰IntRef的引证count
count.element = 0;//包装器内部的非final变量
textView.setOnClickListener((OnClickListener)(new OnClickListener() {
public final void onClick(View it) {
IntRef var10000 = count;
int var2;
var10000.element = (var2 = var10000.element) + 1;
boolean var3 = false;
System.out.println(var2);
}
}));
}
public View _$_findCachedViewById(int var1) {
if (this._$_findViewCache == null) {
this._$_findViewCache = new HashMap();
}
View var2 = (View)this._$_findViewCache.get(var1);
if (var2 == null) {
var2 = this.findViewById(var1);
this._$_findViewCache.put(var1, var2);
}
return var2;
}
public void _$_clearFindViewByIdCache() {
if (this._$_findViewCache != null) {
this._$_findViewCache.clear();
}
}
}
留意：关于在 lambda 表达式内部修正局部变量的值，只会在这个 lambda 表达式被履行的时分触发。
五、Lambda 表达式的成员引证
5.1 为什么运用成员引证？
Lambda 表达式能够直接把一个代码块作为一个参数传递给函数，可是假如要作为参数传递的代码现已被界说成了函数，此刻还需求重复写一个代码块传递曩昔吗？必定不是，这时分就需求 把函数转化成一个值，这种办法称为 成员引证。
fun main(args: Array<String>) {
val persons = arrayListOf(Person("Java", 20), Person("Android", 5))
println(persons.maxBy({ p: Person -> p.age }))
}
{ p: Person -> p.age } 表达式能够用成员引证 Person::age 替换。成员引证和调用函数的 lambda 具有相同的类型，所以能够彼此转化。如下：
fun main(args: Array<String>) {
val persons = arrayListOf(Person("Java", 20), Person("Android", 5))
//println(persons.maxBy({ p: Person -> p.age }))
println(persons.maxBy(Person::age))//成员的引证类型和maxBy()传入Lambda表达式的共同
}
5.2 成员引证的根本语法
上面这种用法称为成员引证，它供给简明语法，来创立一个单个办法或许单个特点的函数值，运用 :: 运算符来转化。成员引证由类名，双冒号，成员三个元素组成。成员是函数名标明引证函数，成员是特点标明引证特点。
5.3 成员引证的运用场景
（1）最常见的运用办法是类名+双冒号+成员（特点或函数）：
fun main(args: Array<String>) {
val persons = arrayListOf(Person("Java", 20), Person("Android", 5))
println(persons.maxBy(Person::age))//成员的引证类型和maxBy()传入Lambda表达式的共同
}
（2）还能够引证顶层函数，这种状况省掉了类称号，直接以 :: 最初。成员引证 ::salute 被当作实参传递给库函数 run()，它会调用相应的函数：
fun saulte() = println("fun saulte") //顶层函数
fun main(args: Array<String>) {
//运用函数引证前
run({ saulte() })
//运用函数引证简化后
run(::saulte)//打印：fun saulte
}
（3）假如 lambda 要托付给一个接纳多个参数的函数，供给成员引证代替它将会十分便利：
//有多个参数的 lambda
val action = { person: Person, message: String -> sendEmail(person, message) }
//运用成员引证代替
val nextAction = ::sendEmail
//调用
nextAction(Person(), "msg")
（4）成员引证用于结构办法。能够用结构办法的引证存储或许延期履行创立类实例的动作，结构办法的引证办法是在双冒号后指定类称号： ::类名
fun main(args: Array<String>) {
val getPerson = ::Person //创立的实例动作就保存成了值
println("结构办法 == " + getPerson("Kotlin", 3))//打印 Person(name=Kotlin, age=3)
}
（5）成员引证还能够运用相同的办法引证扩展函数：
// 这是Person的一个扩展函数，判断是否成年
fun Person.isChild() = age > 18
fun main(args: Array<String>) {
val isChild = Person::isChild
println("isChild == " + isChild(Person("Java", 20)))//打印 true
}
5.4 绑定引证
Kotlin1.1 以上答应你运用成员引证语法 捕捉特定实例目标上的办法引证。
val person = Person("Android", 24) //创立实例
//val personAge = { person.age } //Kotlin1.1之前显式写出 lambda
val personAge = person::age //Kotlin1.1之后能够运用绑定引证
println("person: age == ${personAge()}")//打印 person: age == 24
留意：personAge 是一个零函数的参数，在Kotlin1.1之前你需求显式写出 lambda { person.age }，而不是运用绑定成员引证：person::age。
六、匿名函数
6.1 匿名函数
并非每个函数都需求一个称号，某些函数经过输入和输出更直接地进行标识，这些函数称为匿名函数。匿名函数都是函数字面量，都能够在不显式界说办法的时分供给供给具有相同办法，功用的完成。匿名函数能够明确指定回来类型，匿名函数与惯例函数不同的是没有函数名。
你能够保存某个匿名函数的引证，便利今后运用此引证来调用该匿名函数，与其他引证类型相同，你也能够在引证中心传递引证。
val stringLengthFunc: (String) -> Int = { input ->
input.length
}
与惯例命名函数相同，匿名函数也能够包括恣意数量的表达式，函数回来值是最终表达式的结果。
在上面实例中，stringLengthFunc 包括一个匿名函数的引证，该函数将 String 当作输入，并将输入 String 的长度作为 Int 类型的输出回来。因而，该函数的类型标明为 (String) -> Int 。不过，此代码不会调用该函数，假如要检索该函数的结果，你有必要像调用命名函数相同调用该函数。调用 stringLengthFunc 时，有必要供给 String ，如下所示：
val stringLengthFunc: (String) -> Int = { input ->
input.length
}
val stringLength: Int = stringLengthFunc("Android")
lambda 表达式语法中短少的一点是指定函数回来类型的才能。在大多数状况下，这是不必要的，由于能够主动揣度回来类型。可是，假如你确认需求显式地指定它，能够运用匿名函数。
//惯例函数
fun test(x: Int, y: Int): Int = x + y
//匿名函数
fun(x: Int, y: Int): Int = x + y
匿名函数看起来很像惯例函数声明，除了它的姓名被省掉。它的主体能够是一个表达式（如上述）或一个块：
fun(x: Int, y: Int): Int {
return x + y
}
参数和回来类型的指定办法与惯例函数相同，除了参数类型能够从上下文揣度而省掉：
val items = arrayOf(1, 2, 3, 4, 5)
//回来契合条件的元素的列表
val list = items.filter(fun(item) = item > 2)
println("list == $list")//打印 [3, 4, 5]
匿名函数的回来类型揣度与一般函数的工作办法相同：关于带有表达式体的匿名函数，回来类型主动揣度，关于带有块体的匿名函数，回来类型有必要显式指定（或许假设为Unit）。
留意：匿名函数参数总是在括号内传递。答应将函数放在括号外的简写语法仅适用于lambda表达式。
lambda 表达式和匿名函数之间的另一个差异是非本地回来的行为。没有标签的 return 语句总是从运用 fun 关键字声明的函数回来。这意味着 lambda 表达式中的 return 将从封闭函数回来，而匿名函数内部的 return 将从匿名函数自身回来。
6.2 带有接纳器的函数字面量
在 Kotlin 中，供给了指定接纳者目标调用 Lambda 表达式的功用。在函数字面值的函数体中，能够调用该接纳者目标上的办法而无需额外的约束符。它相似于扩展函数，答应你在函数体内拜访接纳者目标的成员。
带有接纳器的函数类型，例如：A.(B) -> C，能够用函数字面量的特别办法实例化——带有接纳器的函数字面量。
在字面量函数体中，传递给调用的 receiver 目标变成隐式的 this，这样你就能够拜访该 receiver 目标的成员而不需求任何附加约束符，或许运用 this 表达式拜访 receiver 目标。
这儿有一个比如：一个带有接纳器及其类型的函数字面量，其间 plus 在接纳器目标被调用。
val all: Int.(Int) -> Int = { other -> plus(other) }
匿名函数语法答应你直接指定函数字面量的接纳方类型。假如你需求运用 receiver 声明一个函数类型的变量，并在今后运用它，那么这将十分有用。
//直接指定函数字面量的接纳方类型
val all = fun Int.(other: Int): Int = this + other
当能够从上下文揣度接纳者类型时，Lambda表达式能够作为函数字面量与接纳者一同运用。它们运用的一个最重要的比如是类型安全构建器 type-safe builders。
class Student {
fun body() {}
}
fun study(init: Student.() -> Unit): Student {
val student = Student()//创立接纳器目标
student.init()//将接纳器目标传递给lambda
return student
}
//调用
study {//带有接纳器的lambda从这儿开端
body()//调用接纳器目标上的办法
}
七、总结
-
函数 A 能够将函数 B 当作参数（或回来函数），函数 A 被称为“高阶函数”。
-
函数类型：
(A, B) -> C：有一个带括号的参数类型列表和一个回来类型；A.(B) -> C：能够在接纳目标 A 调用 B 类型的参数，回来值为 C 类型的函数；suspend A.(B) -> C：挂起函数特点特性类型的函数，在标明法中有一个挂起润饰符。 -
函数类型的值能够经过运用其
invoke(...)操作符来调用，invoke()标明经过函数变量调用自身。 -
Lambda 表达式实质是匿名函数，没有显式界说办法的时分，能够经过这种办法生成一个具有同等办法，功用的办法。
-
lambda表达式完好句语法：
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }。 lambda 表达式总是在大括号{}包裹着，完好语法办法的参数声明在大括号内，并有能够省掉的参数类型，body 在->符号之后。 -
lambda表达式简写：
A.假如函数 A 的最终一个参数是函数 B，那么作为对应参数传递的 lambda 表达式能够放在函数 A 圆括号 () 外；
B.假如 lambda 表达式是被调用的函数的仅有一个参数，则函数的圆括号 () 能够被彻底省掉；
C.假如 lambda 表达式的参数只要一个，那么不答应声明仅有的参数而且省掉了 -> 符号，用 it 标明这个参数的称号。
-
假如 lambda 表达式有回来值，那么lambda会将最终一条语句作为其回来值。假如运用约束的回来语法显式地从 lambda 回来一个值，则不会再以默许的最终一行回来值。
-
假如 lambda 参数未运用，你能够用下划线
_来代替参数的称号。 -
Lambda表达式的几种运用场景：各种挑选、映射、改换操作符和对调集数据进行各种操作；代替原有匿名内部类；把某个函数当作值传入某个函数的时分。
-
Lambda表达式的成员引证，成员引证由类名，双冒号，成员三个元素组成，用于顶层top-level，本地，成员，扩展函数，结构器或指向特定实例成员的绑定可调用引证。
-
Kotlin中Lambda表达式拜访局部变量、变量捕获以及原理。
-
并非每个函数都需求一个称号，某些函数经过输入和输出更直接地进行标识，这些函数称为匿名函数。匿名函数与惯例函数不同的是没有函数名。
-
匿名函数参数总是在括号内传递，将函数放在括号外的简写语法仅适用于lambda表达式。
-
lambda 表达式中的
return将从封闭函数回来，而匿名函数内部的return将从匿名函数自身回来。
点重视，不走失
好了各位，以上便是这篇文章的全部内容了，很感谢您阅览这篇文章。我是suming，感谢支撑和认可，您的点赞便是我创造的最大动力。山水有相逢，咱们下篇文章见！
本人水平有限，文章难免会有错误，请批评指正，不胜感激 ！
参阅链接：
- Kotlin官网
- 《Kotlin实战》
- 慕课网之《新版Kotlin从入门到精通》
