Kotlin 和 Groovy 的 lambda 对比

一、格式

1.1 完整格式

// Kotlin
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y}
// Groovy
Closure sum = { Integer x, Integer y -> x + y }

Kotlin 的函数类型是变化的，如 (Int, Int) -> Int
Groovy 函数类型只有一个 Closure

1.2 简化格式

// kotlin 
val sumSimple1: (Int, Int) -> Int = { x, y -> x + y }
val sumSimple2 = { x: Int, y: Int -> x + y }
// groovy
sumSimple = { x, y -> x + y }

Kotlin 的 lambda 在赋值个一个变量时，不能完全省去类型声明。在作为一个函数的参数时，可以省略。
Groovy 的 def 也可省略，Kotlin 的 val 不能

二、trailing lambda

当函数的最后一个参数是一个函数类型，可将 lambda 表达式放到参数列表外。

2.1 三个参数

// kotlin
fun a3(x: Int, y: Int, lambda: (Int, Int) -> Int): Int {
    return lambda(x, y)
}
val b = a3(1, 2, { x, y -> x + y })
val bOut = a3(1, 2) { x, y -> x + y }

// Groovy
def a3(def x, def y, Closure closure) {
    closure(x, y)
}
a3(1, 2, { x, y -> x + y })
a3(1, 2) { x, y -> x + y }

2.2 一个参数

// Kotlin
fun a1(lambda: (Int, Int) -> Int): Int {
    return lambda(1, 2)
}
val bOut2 = a1 { x, y -> x + y }

// Groovy
def a1(Closure closure) {
    closure(1, 2)
}
a1 { x, y -> x + y }

三、it

当 lambda 只有一个参数时，可以用 it 来代表。

3.1 作为入参

// Kotlin
fun itFun(lambda: (Int) -> Unit) {
    lambda(1)
}
val itResult = itFun { println(it) }

// Groovy
def itFun(Closure closure) {
    closure(1)
}
itResult = itFun { println(it) }

3.2 赋值给变量

// Kotlin
val it: (Int) -> Unit = { println(it) }
// Groovy
it = { println(it) }

Kotlin 的 lambda 赋值给变量时，需要声明类型。

四、lambda 的返回值

lambda 表达式中最后一个表达式的值，将作为返回值

// Kotlin
val retLambda = {
    1 + 1
    3
}
val retVal = retLambda() // 值为 3

// Groovy
retval = {
    1 + 1
    3
}
retval() // 值为 3

五、无用变量的处理

// Kotlin
val map = mapOf(1 to "a", 2 to "b")
map.forEach { _, value -> print(value) }

// Groovy
map = [1: "a", 2: "b"]
map.each { _, value -> println(_ + value) }

Kotlin 的 _ 可以作为无用变量的声明，只是占位，无法引用；Groovy 的 _ 被认为是一个正常的声明，可以引用。

六、外部变量的访问

都能访问并修改 lambda 表达式外的对象

// Kotlin
val ints = listOf(1, 2, 3)
var sum = 0
ints.filter { it > 0 }.forEach {
    sum += it
}
println(sum) // 6

// Groovy
ints = [1, 2, 3]
sum = 0
ints.findAll { it > 0 }.each {
    sum += it
}
println(sum) // 6

七、invoke

Kotlin 的 lambda 可以用 invoke() 调用，Groovy 没有这种写法。

// Kotlin
val sum = { x: Int, y: Int -> x + y }
sum.invoke(1, 2)
sum(1, 2)

// Groovy
sum = {x, y -> x + y}
sum(1, 2)