本系列学习教程笔记属于详细讲解Kotlin语法的教程，需要快速学习Kotlin语法的小伙伴可以查看“简洁” 系列的教程
快速入门请阅读如下简洁教程：
Kotlin学习教程(一)
Kotlin学习教程(二)
Kotlin学习教程(三)
Kotlin学习教程(四)
Kotlin学习教程(五)
Kotlin学习教程(六)
Kotlin学习教程(七)
Kotlin学习教程(八)
Kotlin学习教程(九)
Kotlin学习教程(十)
Kotlin - 函数与Lambda表达式
#函数
函数是以特定功能组织起来的代码块，函数定义格式如下：
fun sum(arg1: Int, arg2: Int): Int {
return arg1 + arg2
}
如果函数方法体只有一行代码，那可以将 {} 改为 =，去掉 return，表达式的值将作为函数返回值：
fun sum(arg1: Int, arg2: Int) = arg1 + arg2
#默认返回值类型
任何函数都是有返回值的，一般函数方法体中会使用 return 将结果进行返回，但有的函数就是不需要返回结果，此时可以将 return 省略：
fun main(args: Array<String>) {
...
}
即使函数方法体中没有 return 返回结果，但函数还是有返回值类型的，默认的返回值类型就是 Unit ，但一般 Unit 会省略不写：
fun main(args: Array<String>): Unit {
...
}
#匿名函数
匿名函数就是没有名字的函数，但是需要赋值给一个变量，否则 IDE 会报错：
// 变量sum，它的值是一个函数
val sum = fun(arg1: Int, arg2: Int): Int {
return arg1 + arg2
}
fun main(args: Array<String>): Unit {
val result = sum(1, 2)
println(result) // 3
}
此时
sum是一个变量，只是它的值是一个函数。
#Lambda 表达式
Lambda 表达式也是一种"匿名函数"，不过格式上会有些不同：
- {[参数列表] -> [函数体, 最后一行是返回值]}
val sum = { arg1: Int, arg2: Int ->
println("$arg1 + $arg2 = ${arg1 + arg2}")
arg1 + arg2
}
fun main(){
println(sum(1, 2)) // 3
}
Lambda 表达式的返回值是表达式中最后一行的结果。
#Lambda 的类型
Kotlin 中，不管是常量或是变量，都会有各自的类型，如：Human，那如果一个变量的值是 Lambda 表达式，那它的类型是什么呢？没错，就是 Lambda 类型：
- () -> Unit : 无参，返回值为 null
- (Int) -> Int : 传入整型，返回一个整型
- (String, (String)->String) -> Boolean : 传入字符串、Lambda 表达式，返回 Boolean
// lambda的类型：(Int,Int) -> Int
val sum = { arg1: Int, arg2: Int -> arg1 + arg2 }
// lambda的类型：() -> Unit
val printlnHello = {
println("Hello")
}
#Lambda 表达式的调用
与匿名函数一样，值为 Lambda 表达式的变量可通过以下两种方式执行 Lambda 表达式：
- 用
()进行调用 - 用
invoke()调用
println(sum(1, 2)) // 3
println(sum.invoke(1, 2)) // 3
实际上，
()就是invoke()。
#Lambda 表达式的简化
- 函数参数调用时最后一个 Lambda 可以移出去
- 函数参数只有一个 Lambda，调用时小括号可省略
- Lambda 只有一个参数可默认为 it
- 入参、返回值与形参一致的函数可以用函数引用的方式作为实参传入
我们先来看一下 Array 数组的一个扩展函数 forEach：
/**
* Performs the given [action] on each element.
*/
public inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit {
for (element in this) action(element)
}
这个扩展函数为 Array 类扩展了一个 forEach 方法，需要传入一个参数 action，其类型是 (T) -> Unit 的 Lambda 类型，返回值为 Unit（即没有返回值），方法体中使用 for-in 对数组进行遍历，同时使用参数 action 处理遍历的元素。
关于扩展函数这里不展开细讲，后续文章会专门解读，这里只需要知道
forEach的功能即可。
val args = arrayOf("1", "2", "3", "l", "q", "r")
// 使用 for-in 遍历数组并打印元素内容
for (arg in args) {
println(arg)
}
这是一个普通的数组遍历打印功能，上面已经使用 for-in 实现了，下面就使用前面学到的扩展函数 forEach 来处理：
// Lambda完整写法
args.forEach({ it -> println(it) })
// Lambda简化写法
args.forEach({ println(it) })
// 重命名参数it，此时ele不可省略
args.forEach({ ele -> println(ele) })
Lambda 只有一个参数时可默认为 it，当然了，如果你不想使用 it 也是可以改名的，但如果改名了，就不能将其省略。除了省略默认参数 it，还有如下方法简化 Lambda 表达式：
// 函数参数调用时最后一个 Lambda 可以移出去
args.forEach(){ println(it) }
// 函数参数只有一个 Lambda，调用时小括号可省略
args.forEach{ println(it) }
以上就是 Kotlin 中 Lambda 表达式的简化流程，以后开发中会经常遇到最后的简化写法。
#Lambda 表达式与函数引用
再回头看看这个扩展函数 forEach 的参数 action 的类型：
// action: (T) -> Unit
public inline fun <T> Array<out T>.forEach(action: (T) -> Unit): Unit {
for (element in this) action(element)
}
再看看 println() 的定义：
// println: (Any?) -> Unit
public actual inline fun println(message: Any?) {
System.out.println(message)
}
不难发现 println() 的定义完全符合 action 的 Lambda 类型要求，于是此场景下还可以将 forEach 参数 action 需要的 Lambda 表达式转换成 println 函数的引用，引用函数需要使用 :: ：
// 入参、返回值与形参一致的函数可以用函数引用的方式作为实参传入
args.forEach(::println)
#Lambda 表达式跳出 forEach
这里严重超纲，看不明白也无所谓，可以先跳过～
需求：遍历数组时，当发现元素是 q 时，中断循环。
val args = arrayOf("1", "2", "3", "l", "q", "r")
for (arg in args) {
if (arg == "q") break
println(arg)
}
println("The End") // 1 2 3 l The End
使用 for-in 配置 break 即可实现该功能，下面试试使用 forEach：
fun main() {
val args = arrayOf("1", "2", "3", "l", "q", "r")
args.forEach {
if (it == "q") break // IDE报错：'break' and 'continue' are only allowed inside a loop
print("$it ")
}
println("The End")
}
是的，Lambda 表达式仅仅是一个表达式而已，不是循环体，所以无法使用 break 和 continue，那这里为了中断遍历只能使用 return 了：
fun main() {
val args = arrayOf("1", "2", "3", "l", "q", "r")
args.forEach { // 1 2 3 l
if (it == "q") return
print("$it ")
}
println("The End") // 不会被执行
}
乍一看，这里使用了 return 实现了中断遍历，但其实 "The End" 没有输出，说明 return 并非中断遍历，而是中断了当前的 main 函数，原因还是那个：Lambda 表达式仅仅只是表达式而已。
针对 Lambda 表达式，Kotlin 提供了标签式返回，可以在 Lambda 表达式中使用 return@xxx 方法跳出遍历，那使用这个来试试看：
fun main() {
val args = arrayOf("1", "2", "3", "l", "q", "r")
args.forEach {
if (it == "q") return@forEach
print("$it ")
}
println("The End") // 1 2 3 l r The End
}
程序跳过 q 继续往下执行了，这又是什么情况？这还是要回到 Lambda 表达式的本质，forEach里的 Lambda 表达式其实就是一个函数体，因此标签式返回 return@xxx 对这个函数体的退出只能退出当前的调用罢了。那就没有办法使用 forEach 实现这个需求了吗？是的，单靠 forEach 不行，需要配置 StreamApi 对数组进行过滤后再遍历：
val args = arrayOf("1", "2", "3", "l", "q", "r")
args.takeWhile { it != "q" }.forEach { print("$it ") }
println("The End") // 1 2 3 l The End
