Lambda 表达式是一种在现代编程语言中常见的特性,它可以用来创建匿名函数或代码块,使得将函数作为参数传递、简化代码以及实现函数式编程范式变得更加便捷。Lambda 表达式在函数式编程语言中得到广泛应用,也在诸如 Java 8 和 Kotlin 等主流编程语言中引入。
在 Java 中,Lambda 表达式是从 Java 8 版本开始引入的一项重要特性,它允许我们以更简洁的方式创建匿名函数,从而在处理函数式编程、回调等场景中变得更加方便。Lambda 表达式的引入在 Java 中使得编写代码变得更加紧凑,同时也提供了更强大的函数式编程能力。
以下是 Java 中 Lambda 表达式的基本概念和语法:
(parameters) -> { }
parameters
是 Lambda 表达式的参数列表。参数的类型可以根据上下文进行类型推断。->
是 Lambda 表达式的箭头符号,分隔参数列表和函数体。{ }
是 Lambda 表达式的函数体,可以是一行或多行代码。
Lambda 表达式通常用于函数式接口(Functional Interface)中,这是一个只包含一个抽象方法的接口。Lambda 表达式可以实现这个接口的抽象方法,从而将匿名函数传递给方法或函数。
以下是一个简单的示例,展示了如何在 Java 中使用 Lambda 表达式:
public class LambdaExample { public static void main(String[] args) { // Lambda 表达式作为参数传递给 Thread 的构造函数 Thread thread = new Thread(() -> { System.out.println("Thread is running"); }); thread.start(); }}
在这个示例中,Lambda 表达式 () -> { System.out.println("Thread is running"); }
被传递给 Thread
类的构造函数,用作线程的任务(Runnable
)。这样就避免了传统的匿名内部类的繁琐语法,使代码更加简洁。
需要注意的是,Lambda 表达式在 Java 中需要满足以下要求:
- Lambda 表达式只能用于函数式接口中,该接口必须只包含一个抽象方法。
- 如果接口有默认方法(
default
关键字修饰的方法),那么它不会影响函数式接口的定义。 - 在 Lambda 表达式中可以捕获
final
或 effectively final 的局部变量。
通过掌握 Java 中的 Lambda 表达式,你可以在代码中更自然地表达函数式概念,从而编写更简洁、高效的代码。
在 Kotlin 中,Lambda 表达式是一种强大的特性,允许你以简洁的方式创建匿名函数,从而在函数式编程、集合操作等场景中变得更加方便。Kotlin 的 Lambda 表达式语法非常灵活,与函数的声明和调用紧密结合,使得代码更加清晰和易读。
以下是 Kotlin 中 Lambda 表达式的基本语法和一些重要概念:
{ parameters -> }
可以看出和 Java 的Lambda语法类似,只不过这个箭头是放在了大括号的里面,而不是外面。
parameters
是 Lambda 表达式的参数列表。参数的类型可以根据上下文进行类型推断。->
是 Lambda 表达式的箭头符号,分隔参数列表和函数体。{ }
是 Lambda 表达式的函数体,可以是一行或多行代码。
Lambda 表达式通常用于函数式接口(Functional Interface)中,或者用于集合操作、高阶函数等情境中。
以下是一个简单的示例,展示了如何在 Kotlin 中使用 Lambda 表达式:
fun main() { val thread = Thread ({ -> println("Thread is running") }) thread.start()}
如果 Lambda 是函数的最后一个参数,可以将大括号放在小括号外面:
fun main() { val thread = Thread() { -> println("Thread is running") } thread.start()}
如果函数只有一个参数且这个参数是 Lambda,则可以省略小括号:
fun main() { val thread = Thread { -> println("Thread is running") } thread.start()}
如果 Lambda 表达式没有参数,你可以直接省略 ->
符号:
fun main() { val thread = Thread { println("Thread is running") } thread.start()}
好了,就此我们看一下 Java 和 Kotlin 的 Lambda 表达式,如图所示:
Kotlin 的 Lambda 表达式本质上就是闭包,它是一种可以捕获并携带作用域中变量状态的函数。Lambda 闭包在 Kotlin 中具有以下特点:
- 捕获变量: Lambda 表达式可以在其作用域外捕获外部变量。这意味着 Lambda 表达式可以访问外部作用域中的变量,即使在该作用域已经结束的情况下。捕获的变量可以是
val
或var
,但在 Lambda 表达式中只能被读取,不能被修改(对于val
)。 - 记住状态: Lambda 表达式捕获的变量状态在闭包内是“记住”的,即使闭包被传递到其他函数或在不同上下文中执行,它仍然可以访问并使用这些变量。
- 隐式参数: 当 Lambda 表达式只有一个参数时,可以使用隐式参数
it
来代表这个参数。这使得代码更加简洁。 - 函数式编程: Lambda 闭包使得 Kotlin 可以支持函数式编程范式,使代码更加模块化、易读和易于测试。
Kotlin 的 Lambda 闭包(也称为 Lambda 表达式)具有以下基本格式:
val lambdaName: (parameters) -> returnType = { arguments -> // Lambda 表达式的主体}
我们解释一下每个部分的含义:
val lambdaName
: 这是 Lambda 表达式的变量名,你可以根据需要命名它。(parameters) -> returnType
: 这是 Lambda 表达式的类型,它指定了参数列表和返回类型。parameters
是参数列表,可以是一个或多个参数,用逗号分隔。returnType
是返回类型,指示 Lambda 表达式返回的值的类型。arguments ->
: 这是 Lambda 表达式的参数部分。arguments
是 Lambda 表达式的参数,你可以为参数指定名称。箭头->
分隔了参数和主体部分。{ }
: 这是 Lambda 表达式的主体,包含了 Lambda 表达式的实际逻辑和操作。这部分代码会在 Lambda 表达式被调用时执行。
下面是一个简单的示例,演示如何声明一个 Kotlin 的 Lambda 闭包:
fun main() { person.invoke("danke") person("danke")}val person: (name: String) -> Unit = { name: String -> println("name is $name") // 可以省略Unit}
在这个示例中,我们首先声明了一个名为 person
的变量,其值是一个 Lambda 表达式。这个 Lambda 表达式接受一个 String
类型的参数 name
,并在闭包体内使用 $name
来将参数的值嵌入到字符串中。这个 Lambda 表达式就是 Lambda 闭包。
在 Kotlin 中,如果一个 Lambda 表达式没有返回值,可以使用 Unit
来表示。Unit
实际上是一个类型,类似于 Java 中的 void
,但它是一个真正的类型,表示一个只有一个值的类型。
当 Lambda 表达式没有明确的返回值时,Kotlin 会默认将其推断为 Unit
类型。因此,你可以省略不写返回值类型。
接下来,在 main
函数中,我们通过两种方式来调用 person
这个闭包:
person.invoke("danke")
:这里使用invoke
函数来显式地调用闭包,并传递参数"danke"
。person("danke")
:这是一种更简洁的方式,直接像调用函数一样调用闭包,并传递参数"danke"
。
无论使用哪种方式,闭包都会执行,打印出 "name is danke"
。
上面示例展示了如何声明一个 Kotlin 的 Lambda 闭包,并且演示了如何调用闭包并传递参数。闭包在 Kotlin 中是一种非常强大的概念,允许在代码中以一种更函数式的方式操作数据和逻辑。
在 Kotlin 中,如果 Lambda 表达式的参数和返回类型可以从上下文中推断出来,你可以省略参数列表和返回类型的定义。那么我们改造一下上面声明的 Lambda 闭包,其中省略了参数列表和返回类型的定义:
val person = { name: String -> println("name is $name") }
在这个示例中,由于 Lambda 表达式的参数类型和返回类型可以从赋值操作的右侧(Lambda 表达式)推断出来,所以我们可以省略掉 (name: String) -> Unit
这部分。编译器会自动推断出参数类型为 String
,返回类型为 Unit
。
这种简化的写法使代码更加简洁,但需要注意的是,当 Lambda 表达式的参数和返回类型不容易从上下文中推断出时,最好还是显式地声明它们,以增加代码的可读性和清晰性。
Kotlin 的 Lambda 闭包使得函数变得更具表达力和灵活性。它们可以用于各种情境,从集合操作到异步编程,从而提供了更多的编程选择和优雅的语法。
在 Kotlin 中,Lambda 表达式的参数数量是有上限的,这个上限与函数式接口的抽象方法数量有关。通常情况下,Lambda 表达式的参数数量最多为 22,因为 Kotlin 的标准库中提供了 22 个用于函数式编程的函数式接口(如 Function0
到 Function22
)。
这意味着你可以创建一个具有最多 22 个参数的 Lambda 表达式。如果我们尝试给 Lambda 表达式添加第 23 个参数的时候,例如:
fun main() { maxParams( 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 )}val maxParams = { p1: Int, p2: Int, p3: Int, p4: Int, p5: Int, p6: Int, p7: Int, p8: Int, p9: Int, p10: Int, p11: Int, p12: Int, p13: Int, p14: Int, p15: Int, p16: Int, p17: Int, p18: Int, p19: Int, p20: Int, p21: Int, p22: Int, p23: Int -> println("maxParams") }
看到最终运行这段代码就抛出一个异常:java.lang.NoClassNotFoundError:kotlin/Function23。为什么它最后报没有Function23这样的一个类呢?这是因为 Kotlin 的类在编译以后会被编译成 class 文件,Kotlin 的 lambda 在编译以后会被编译成一个匿名内部类,我们定义 lambda 表达式有 23 个参数,它也是一个匿名类,但是我们在的 Kotlin 的源码中,看到只定义了 22 个 Function,这个 Function 后面紧跟着数字,就表示有多少个参数。从零开始表示没有参数,一直到 22。我们可以看一下 Kotlin 源码:
因此参数数量超过 22 的 Lambda 表达式在调用时会引发错误。这是 Kotlin 的限制,Lambda 表达式的参数数量应该小于等于 22。
有没有办法解决?
如果我们给 Lambda 传了23个参数的时候,它就会直接报错了。那么这个问题能不能解决呢?当然也是可以的!就是我们手动去定义这个 Function23 这样的一个类。在定义这样一个类的时候,我们可能还会碰上问题。首先,我们一起来在代码中试一下。
// Function23.ktpackage kotlinpublic interface Function23<in P1, in P2, in P3, in P4, in P5, in P6, in P7, in P8, in P9, in P10, in P11, in P12, in P13, in P14, in P15, in P16, in P17, in P18, in P19, in P20, in P21, in P22, in P23, out R> : Function<R> { public operator fun invoke(p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, p11: P11, p12: P12, p13: P13, p14: P14, p15: P15, p16: P16, p17: P17, p18: P18, p19: P19, p20: P20, p21: P21, p22: P22, p23: P23): R}
首先创建Function23.kt,并将这个类的包名改成package kotlin。我们假设在 Kotlin 这个包下面创建一个 Function23 这样的一个类。那么它的类的声明是跟前面 Function22 完全一致,只是多了一个参数,我们就直接拷过来。这样我们就定义完成了 Function23。
然后我们再来运行这样的一段代码。看到编译器给我们报出来了一个错误,说只有Kotlin 的标准库才可以使用 Kotlin 这样的一个包名。而我们自己声明的类,是不能声明一个类的包名叫Kotlin的。
Kotlin: Only the Kotlin standard library is allowed to use the 'kotlin' package
那么,这个问题怎么解决呢?
大家回想一下 Kotlin 与 Java 是完全兼容的,如果我们不能以 Kotlin 的形式去声明一个类的话,那是不是可以用 Java 的形式去声明它?
public interface Function23<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21, P22, P23, R> extends Function<R> { R invoke(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12, P13 p13, P14 p14, P15 p15, P16 p16, P17 p17, P18 p18, P19 p19, P20 p20, P21 p21, P22 p22, P23 p23);}
所以咱们能够将这个Function23 申明为一个 Java类,并将它的包名设置为kotlin,这样就能够申明参数个数超过 22 的闭包了。
然而,使用拥有如此多参数的 Lambda 表达式往往会导致代码的可读性降低,而且实际情况下很少会需要这么多参数。在大多数情况下,Lambda 表达式的参数数量应该保持合理,以确保代码的清晰度和可维护性。
除了上限之外,Kotlin 还支持使用 vararg
关键字来定义一个接受可变数量参数的 Lambda 表达式,类似于普通函数的可变参数。(在上文中已经介绍过了)
总之,Kotlin 的 Lambda 表达式参数数量上限为 22,但实际中应该遵循良好的编程实践,保持适度的参数数量,以提高代码的可读性和可维护性。
Kotlin 文件 LambdaTest.kt
:
val person = { name: String -> println("name is $name") }
Java 文件 Main.java
:
import kotlin.Unit;import kotlin.jvm.functions.Function1;public class java8 { public static void main(String[] args) { Function1<String, Unit> person = LambdaTestKt.getPerson(); person.invoke("danke"); }}
在这个示例中,我们在 Java 中通过 LambdaTestKt.getPerson()
方法来获取 Kotlin 文件中定义的 person
Lambda 表达式实例,然后通过 person.invoke("danke")
调用该 Lambda 表达式。
这种方式可以在 Java 中调用 Kotlin 文件中的顶层 Lambda 表达式。