科特林 | Lambdas 表达式和匿名函数

在本文中，我们将学习 Kotlin 中的 lambdas 表达式和匿名函数。虽然语法相似，但 Kotlin 和Java lambda 具有非常不同的特性。

Lambda 表达式和匿名函数都是函数字面量，这意味着这些函数没有声明，而是作为表达式立即传递。

Lambda 表达式 –

众所周知，Kotlin lambdas 的语法类似于Java Lambdas。没有名称的函数称为匿名函数。对于 lambda 表达式，我们可以说它是匿名函数。

例子：

Kotlin

fun main(args: Array) {
    val company = { println("GeeksforGeeks")}
 
    // invoking function method1
    company() 
 
    // invoking function method2
    company.invoke()
}

输出：

GeeksforGeeks
GeeksforGeeks

Lambda 表达式的语法 –

val lambda_name : Data_type = { argument_List -> code_body }

一个 lambda 表达式总是被花括号包围，参数声明放在花括号内并有可选的类型注释，code_body 位于箭头->符号之后。如果推断的 lambda 的返回类型不是 Unit，则 lambda 主体内的最后一个表达式被视为返回值。

例子：

val sum = {a: Int , b: Int -> a + b}

在 Kotlin 中，lambda 表达式包含除 code_body 之外的可选部分。下面是去掉可选部分后的 lambda 表达式。

val sum:(Int,Int) -> Int = { a, b -> a + b}

注意：我们并不总是需要变量，因为它可以直接作为参数传递给函数。

使用 lambda 表达式的 Kotlin 程序-

科特林

// with type annotation in lambda expression
val sum1 = { a: Int, b: Int -> a + b }
 
// without type annotation in lambda expression
val sum2:(Int,Int)-> Int  = { a , b -> a + b}
 
fun main(args: Array) {
    val result1 = sum1(2,3)
    val result2 = sum2(3,4)
    println("The sum of two numbers is: $result1")
    println("The sum of two numbers is: $result2")
 
    // directly print the return value of lambda
    // without storing in a variable.
    println(sum1(5,7))
}

输出：

The sum of two numbers is: 5
The sum of two numbers is: 7
12

lambdas 中的类型推断-

Kotlin 的类型推断帮助编译器评估 lambda 表达式的类型。下面是 lambda 表达式，我们可以使用它来计算两个整数的和。

val sum = {a: Int , b: Int -> a + b}

在这里，Kotlin 编译器将其作为一个函数进行自我评估，该函数接受两个 Int 类型的参数并返回 Int 值。

(Int,Int) -> Int

如果我们想返回字符串值，我们可以借助 toString() 内置函数实现。

科特林

val sum1 = { a: Int, b: Int ->
    val num = a + b
    num.toString()     //convert Integer to String
}
fun main(args: Array) {
    val result1 = sum1(2,3)
    println("The sum of two numbers is: $result1")
}

输出：

The sum of two numbers is: 5

在上面的程序中，Kotlin 编译器将其作为一个函数进行自我评估，该函数接受两个整数值并返回字符串。

(Int,Int) -> String  

lambda 中的类型声明 –

我们必须显式声明 lambda 表达式的类型。如果 lambda 没有返回值，那么我们可以使用： Unit
模式：（输入）-> 输出

具有返回类型的 Lambdas 示例 –

val lambda1: (Int) -> Int = (a -> a * a)
val lambda2: (String,String) -> String = { a , b -> a + b }
val lambda3: (Int)-> Unit = {print(Int)}

Lambda 可以用作类扩展：

val lambda4: String.(Int) -> String = {this + it} 

在这里，它表示单个参数的隐含名称，我们将在后面讨论。

当 lambdas 用作类扩展时的 Kotlin 程序 –

科特林

val lambda4 : String.(Int) -> String = { this + it }
 
fun main(args: Array) {
    val result = "Geeks".lambda4(50)
    print(result)
}

输出：

Geeks50

解释：
在上面的示例中，我们使用 lambda 表达式作为类扩展。我们已经按照上面给出的格式传递了参数。 this关键字用于字符串， it关键字用于 lambda 中传递的 Int 参数。然后 code_body 连接两个值并返回变量结果。

it：单个参数的隐式名称 –

在大多数情况下，lambdas 包含单个参数。在这里，它用于表示我们传递给 lambda 表达式的单个参数。

Kotlin 程序使用 lambda函数的简写形式——

科特林

val numbers = arrayOf(1,-2,3,-4,5)
 
fun main(args: Array) {
      println(numbers.filter {  it > 0 })
}

输出：

[1, 3, 5]

使用 lambda函数的速记形式的 Kotlin 程序 –

科特林

val numbers = arrayOf(1,-2,3,-4,5)
 
fun main(args: Array) {
     println(numbers.filter {item -> item > 0 })
}

输出：

[1, 3, 5] 

从 lambda 表达式返回一个值 -

执行 lambda 后，lambda 表达式返回的最终值。 lambda函数可以返回任何这些整数、字符串或布尔值。

Kotlin 程序通过 lambda函数返回字符串值 -

科特林

val find =fun(num: Int): String{
if(num % 2==0 && num < 0) {
    return "Number is even and negative"
   }
    else if (num %2 ==0 && num >0){
    return "Number is even and positive"
    }
    else if(num %2 !=0 && num < 0){
    return "Number is odd and negative"
    }
    else {
    return "Number is odd and positive"
    }
}
fun main(args: Array) {
    val result = find(112)
    println(result)
}

输出：

Number is even and positive

匿名函数

匿名函数与常规函数非常相似，只是在声明中省略了函数的名称。匿名函数的主体可以是表达式或块。

示例 1：作为表达式的函数体

fun(a: Int, b: Int) : Int = a * b

示例 2：作为块的函数体

fun(a: Int, b: Int): Int {
    val mul = a * b
    return mul
}

返回类型和参数-

1. 返回类型和参数也以与常规函数相同的方式指定，但如果可以从上下文中推断出参数，我们可以省略它们。
2. 如果函数函数自动推断出来，如果它是主体块，则必须为匿名函数显式指定。

lambda 表达式和匿名函数之间的区别-
唯一的区别是非本地返回的行为。没有标签的 return 语句总是从用 fun 关键字声明的函数返回。这意味着 lambda 表达式内的 return 将从封闭函数返回，而匿名函数内的 return 将从匿名函数本身返回。

Kotlin 程序调用匿名函数-

Java

// anonymous function with body as an expression
val anonymous1 = fun(x: Int, y: Int): Int = x + y
 
// anonymous function with body as a block
val anonymous2 = fun(a: Int, b: Int): Int {
            val mul = a * b
            return mul
            }
fun main(args: Array) {
    //invoking functions
    val sum = anonymous1(3,5)
    val mul = anonymous2(3,5)
    println("The sum of two numbers is: $sum")
    println("The multiply of two numbers is: $mul")
}

输出：

The sum of two numbers is: 8
The multiply of two numbers is: 15