基本语法
people.maxBy({ p: Person -> p.age })
如果 lambda 表达式是函数调用的最后一个实参，它可以放到括号的外边。
people.maxBy() { p: Person -> p.age }
当 lambda 是函数唯一的实参时，你还可以去掉调用代码中的空括号对。
people.maxBy { p: Person -> p.age }
如果 lambda 参数的类型可以被推导出来，你就不需要显式地指定它。
people.maxBy { p -> p.age } // 推导出参数类型
最后简化使用默认参数名称it代替命名参数。如果当前上下文期望的是只有一个参数的 lambda 且这个参数的类型可以推断出来，就会生成这个名称。
people.maxBy { it.age } // “it”是自动生成的参数名称
如果你用变量存储 lambda，那么就没有可以推断出参数类型的上下文，所以你必须显式地指定参数类型：
>>> val getAge = { p: Person -> p.age }
>>> people.maxBy(getAge)
访问变量
Kotlin 和 Java 的一个显著区别就是，在 Kotlin 中你不会仅限于访问 final 变量。在 lambda 内部你也可以修改这些变量。
fun printProblemCounts(responses: Collection) {
var clientErrors = 0 // 声明将在 lambda 内部访问的变量
var serverErrors = 0
responses.forEach {
if (it.startsWith("4")) {
clientErrors++ // 在 lambda 里修改变量
} else if (it.startsWith("5")) {
serverErrors++
}
}
println("$clientErrors client errors, $serverErrors server errors")
}
成员引用
Kotlin 和 Java 8 一样，如果你把函数转换成一个值，你就可以传递它。你使用::运算符来转换，这种表达式称为成员引用：
val getAge = Person::age
你还可以引用顶层函数（不是类的成员）：
fun salute() = println("Salute!")
>>> run(::salute) // 引用顶层函数
Salute!
注意你还可以用同样的方式引用扩展函数：
fun Person.isAdult() = age >= 21
val predicate = Person::isAdult
你可以用构造方法引用存储或者延期执行创建类实例的动作。构造方法引用的形式是在双冒号后指定类名称
data class Person(val name: String, val age: Int)
>>> val createPerson = ::Person // 创建“Person”实例的动作被保存成了值
>>> val p = createPerson("Alice", 29)
>>> println(p)
Person(name=Alice, age=29)
使用 Java 函数式接口
在 Java 中我们随处可见这样的代码
button.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
...
}
});
在 Kotlin 中，你可以传递一个 lambda，代替这个实例
button.setOnClickListener { view -> ... }
但是你需要注意，只有在调用 Java 中的类似函数时才能缩写成这样简单的lambda，如果你调用的是Kotlin 的函数，你需要在 lambda 前面显示的加上类型名字，强制将 lambda 转换成对应的接口类型
setRunnable(Runnable { println("All done!") })
OnClickListener接口只有一个抽象方法，这种接口被称为函数式接口，或者SAM 接口，SAM 代表单抽象方法[译注：_S_ingle _A_bstract _M_ethod]。Java API 中随处可见像Runnable和Callable这样的函数式接口。
当然我们也可以通过匿名对象来实现
button.setOnClickListener(object : OnClickListener { // 把对象表达式作为函数式接口的实现传递
override fun onClick(View v) {
...
}
})
不过很显然，这样的写法并不简洁。
还有一个重要的不同是，当你显式地声明对象时，每次调用都会创建一个新的实例。使用 lambda 的情况不同：如果 lambda 没有访问任何来自定义它的函数的变量，相应的匿名类实例可以在多次调用之间重用：
button.setOnClickListener { view -> ... }// 整个程序只会创建一个 OnClickListener 的实例
然后，如果 lambda 从包围它的作用域里捕捉了变量，每次调用就不再可能重用同一个实例了。这种情况下，每次调用时编译器都要创建一个新对象，其中存储着被捕捉的变量的值。
fun handleComputation(id: String) { // lambda 会捕捉”id“这个变量
postponeComputation(1000) { println(id) } // 每次 handleComputation 调用时都创建一个 Runnable 的新实例
}
SAM 构造方法显式地把 lambda 转换成函数式接口
fun createAllDoneRunnable(): Runnable {
return Runnable { println("All done!") }
}
>>> createAllDoneRunnable().run()
All done!
val listener = OnClickListener { view ->
val text = when (view.id) { // 使用 view.id 来判断点击的是哪个按钮
R.id.button1 -> "First button"
R.id.button2 -> "Second button"
else -> "Unknown button"
}
toast(text) // 把“text”的值显示给用户
}
button1.setOnClickListener(listener)
button2.setOnClickListener(listener)
“with”函数
来看一个例子：
fun alphabet(): String {
val result = StringBuilder()
for (letter in 'A'..'Z') {
result.append(letter)
}
result.append("\nNow I know the alphabet!")
return result.toString()
}
>>> println(alphabet())
ABCDEFGHIJKLMNOPQRSTUVWXYZ
Now I know the alphabet!
使用 with函数改造
fun alphabet(): String {
val stringBuilder = StringBuilder()
return with(stringBuilder) { // 指定接收者的值，你会调用它的方法
for (letter in 'A'..'Z') {
this.append(letter) // 通过显式的“this”来调用接收者值的方法
}
append("\nNow I know the alphabet!") // 省掉“this”也可以调用方法，
this.toString() // 从 lambda 返回值
}
}
进一步改造
fun alphabet() = with(StringBuilder()) {
for (letter in 'A'..'Z') {
append(letter)
}
append("\nNow I know the alphabet!")
toString()
}
with返回的值是执行 lambda 代码的结果。该结果就是 lambda 里的最后一个表达式（的值）。
但有时候你想返回的是接收者对象，而不是执行 lambda 的结果。这时apply库函数就派上用场了。
“apply”函数
apply函数几乎和with函数一模一样；唯一的区别是apply始终会返回作为实参传递给它的对象（换句话说，接收者对象）。让我们再一次重构alphabet函数，这一次用的是apply。
fun alphabet() = StringBuilder().apply {
for (letter in 'A'..'Z') {
append(letter)
}
append("\nNow I know the alphabet!")
}.toString()
另外，在kotlin标准库中查看apply函数的源码
inline fun T.apply(block: T.() -> Unit): T
你会发现T.() -> Unit，我们平时定义函数类型参数难道不是() -> Unit吗？
这里是有区别的，前者表示带有接受者的函数类型，也就是在这个函数内部的this表示的是接受者实例。而后者使用的this表示包含这个函数的外部类。