声明高阶函数
val sum = { x: Int, y: Int -> x + y }
显示声明
val sum: (Int, Int) -> Int = { x, y -> x + y }
函数类型的返回值也可以标记为可空类型：
var canReturnNull: (Int, Int) -> Int? = { null }
定义一个函数类型的可空变量
var funOrNull: ((Int, Int) -> Int)? = null
调用作为参数的函数
fun twoAndThree(operation: (Int, Int) -> Int) {
// 调用函数类型的参数
val result = operation(2, 3)
println("The result is $result")
}
>>> twoAndThree { a, b -> a + b }
The result is 5
>>> twoAndThree { a, b -> a * b }
The result is 6
看到这个调用我们很自然的会想到，在 Java 中该怎么调用这样的方法呢？
其背后的原理是，函数类型被声明为普通的接口：一个函数类型的变量是FunctionN接口的一个实现。Kotlin 标准库定义了一系列的接口，这些接口对应于不同参数数量的函数：Function0<R>（没有参数的函数），Function1<P1,R>（一个参数的函数），等等。每个接口定义了一个invoke方法，调用这个方法就会执行函数。一个函数类型的变量就是实现了对应的FunctionN接口的实现类的实例，实现类的invoke方法包含了 lambda。
Java 8 的 lambda 会被自动转换为函数类型的值。
/* Kotlin 声明 */
fun processTheAnswer(f: (Int) -> Int) {
println(f(42))
}
/* Java */
>>> processTheAnswer(number -> number + 1);
43
在旧版的 Java 中，你可以传递一个实现了函数接口中的invoke方法的匿名类的实例：
/* Java */
>>> processTheAnswer(
// 在Java代码中使用函数类型（Java 8以前）
new Function1<Integer, Integer>() {
@Override
public Integer invoke(Integer number) {
System.out.println(number);
return number + 1;
}
});
43
Java 中你可以很容易地使用 Kotlin 标准库中以 lambda 作为参数的扩展函数。但是要注意它们看起来并没有Kotlin中那么直观——你必须要显式地传递一个接收者对象作为第一个参数：
/* Java */
>>> List<String> strings = new ArrayList();
>>> strings.add("42");
// 你可以在 Java 代码中使用 Kotlin 标准库中的函数
>>> CollectionsKt.forEach(strings, s -> {
System.out.println(s);
// 必须要显式地返回一个Unit类型的值
return Unit.INSTANCE;
});
在 Java 中，函数或者 lambda 可以返回Unit。但因为在Kotlin 中Unit类型是有一个值的，所以需要显式地返回它。一个返回void的 lambda 不能作为返回Unit的函数类型的实参，就像之前的例子中的(String) -> Unit。
内联函数：inline
为什么要用内联函数？
每调用一次 lambda 表达式，一个额外的类就会被创建。并且如果 lambda 捕捉了某个变量，那么每次调用的时候都会创建一个新的对象。这会带来运行时的额外开销，导致使用 lambda 比使用一个直接执行相同代码的函数效率更低。
定义：
inline fun <T> synchronized(lock: Lock, action: () -> T): T {
lock.lock()
try {
return action()
}
finally {
ock.unlock()
}
}
使用内联函数
fun foo(l: Lock) {
println("Before sync")
synchronized(l) {
println("Action")
}
println("After sync")
}
下图展示的是作用相同的代码，将会被编译成同样的字节码：
注意上看代码中传递给
synchronized内联函数的第二个参数是一个lambda，它也被内联了！！！
但是，如果传递给内联函数作为参数的只是一个函数类型的变量：
class LockOwner(val lock: Lock) {
fun runUnderLock(body: () -> Unit) {
// 传递一个函数类型的变量作为参数，而不是一个 lambda
synchronized(lock, body)
}
}
runUnderLock函数会被编译成类似于以下函数的字节码：
class LockOwner(val lock: Lock) {
// 这个函数类似于真正的runUnderLock被编译成的字节码
fun___runUnderLock__(body: () -> Unit) {
lock.lock()
try {
// body没有被内联，因为在调用的地方还没有 lambda
body()
}
finally {
lock.unlock()
}
}
}
在编译器做内联操作的时候，这个body其实是没有真正意义上的函数体的，所以将不会跟内联函数一起被展开。
内联函数的限制
lambda 参数如果被直接调用或者作为参数传递给另外一个 inline 函数， 它是可以被内联的。否则的话，编译器会禁止参数被内联并给出错误信息“Illegal usage of inline-parameter”（非法使用内联参数）。
-
如果一个函数期望两个或更多 lambda 参数，你可以选择只内联其中一些参数。因为一个 lambda 可能会包含很多代码或者以不允许内联的方式使用。
如果你要内联的函数很大，将它的字节码拷贝到每一个调用点将会极大的增加字节码的长度。在这种情况下，你应该将那些与 lambda 参数无关的代码抽取到一个独立的非内联函数中。
接受这样的非内联 lambda 的参数，你可以用noinline修饰符来标记它：
```kotlin
inline fun foo(inlined: () -> Unit, noinline notInlined: () -> Unit) {
// ...
}
```
- 编译器完全支持内联跨模块的函数或者第三方库定义的函数。你也可以在 Java 中调用绝大部分内联函数，但这些调用并不会被内联，而是被编译成普通的函数调用。
Kotlin 标准库函数都是内联函数，但会产生中间集合；而改用
asSequence以后，lambda将被保存在中间序列对象中，因此不会被内联。两者个有优劣，处理大量数据的集合时asSequence有用，小的集合可以用普通的集合操作处理。use这个内联函数很有用，并在Kotlin的流操作和文件操作函数中被广泛使用，函数定义：
public inline fun <T : Closeable?, R> T.use(block: (T) -> R): R {
var exception: Throwable? = null
try {
return block(this)
} catch (e: Throwable) {
exception = e
throw e
} finally {
when {
apiVersionIsAtLeast(1, 1, 0) -> this.closeFinally(exception)
this == null -> {}
exception == null -> close()
else ->
try {
close()
} catch (closeException: Throwable) {
// cause.addSuppressed(closeException) // ignored here
}
}
}
}
高阶函数中的控制流
非局部返回
如果你在lambda中使用return关键字，它会从调用lambda的函数中返回，并不只是从lambda中返回。这样的return语句叫做非局部返回，因为它从一个比包含return的代码块更大的代码块中返回了。
局部返回
你也可以在lambda表达式中使用局部返回，使用标签。想从一个lambda表达式处返回你可以标记它，然后在return关键字后面引用这个标签。
fun lookForAlice(people: List<Person>) {
// 标记lambda表达式
people.forEach label@{
// return@label 引用标签
if (it.name == "Alice") return@label
}
// 这行总是会被打印出来
println("Alice might be somewhere")
}
>>> lookForAlice(people)
Alice might be somewhere
另外一种选择是，使用lambda作为参数的函数的函数名可以作为标签。
fun lookForAlice(people: List<Person>) {
people.forEach {
// return@forEach 从lambda表达式返回
if (it.name == "Alice") return@forEach
}
println("Alice might be somewhere")
}
如果你显式地指定了lambda表达式的标签，再使用函数名作为标签没有任何效果。一个lambda表达式的标签数量不能多于一个。
如果你给带接收者的lambda指定标签，就可以通过对应的带有标签的
this表达式访问它的隐式接收者：// 这个lambda的隐式接收者可以通过this@sb访问 >>> println(StringBuilder().apply sb@{ // “this”指向作用域内最近的隐式接收者 ... listOf(1, 2, 3).apply { // 所有隐式接收者都可以被访问，外层的通过显式的标签访问 ... this@sb.append(this.toString()) ... } ... }) [1, 2, 3]
非局部返回的语法相当的冗长，如果一个lambda包含多个返回语句会变得更加的笨重。解决方案是，你可以使用另一种可选的语法来传递代码块：匿名函数
fun lookForAlice(people: List<Person>) {
// 使用匿名函数取代lambda表达式
people.forEach(fun (person) {
// “return”指向最近的函数：一个匿名函数
if (person.name == "Alice") return
println("${person.name} is not Alice")
})
}
匿名函数和普通函数有相同的指定返回值类型的规则。
people.filter(fun (person): Boolean {
return person.age < 30
})
如果使用表达式函数体，就可以省略返回类型。
people.filter(fun (person) = person.age < 30)
这条规则很简单：return从最近的使用fun关键字声明的函数返回。lambda表达式没有使用fun关键字，所以lambda中的return从最外层的函数返回。
