阅读 354

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 表达式仅仅是一个表达式而已,不是循环体,所以无法使用 breakcontinue,那这里为了中断遍历只能使用 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
复制代码

文章分类
Android
文章标签