Kotlin高阶函数摘要

声明高阶函数

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")
}

下图展示的是作用相同的代码，将会被编译成同样的字节码：

inline.png

注意上看代码中传递给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从最外层的函数返回。