Kotlin知识归纳（十一） —— 高阶函数

前序

之前已经掌握了函数类型的定义以及lambda的使用，本次将完成高阶函数与内联函数的学习。

高阶函数就是以另一函数作为参数或返回值的函数。

函数类型

函数类型的原理

众所周知，Kotlin是兼容Java 6的，但Java 6并没有 lambda 。所以Kotlin会将一个函数类型的变量转换为一个FunctionN接口的实现。

Kotlin标准库中定义了一系列FunctionN接口，这些接口对应于不同参数数量的函数：Function0<R>代表没有参数的函数，Function1<P1,R>代表一个参数的函数。N的取值范围： 0 <= N <= 22,也就是说函数类型变量的参数最多22个。

image

public interface Function0<out R> : Function<R> {
    /** Invokes the function. */
    public operator fun invoke(): R
}

每一个FunctionN接口都定义了一个invoke方法，一个函数类型的变量就是实现了对应FunctionN接口的实例，该 FunctionN接口的实例 invoke 方法中包含了函数类型变量的函数体。

函数类型实例的调用

细心点会发现，每一个FunctionN函数中的invoke()都带有operator关键字修饰，这表明invoke()的调用可以用操作符替代：

表达式	转换
a()	a.invoke()
a(i)	a.invoke(i)
a(i, j)	a.invoke(i, j)
a(i_1, ……, i_n)	a.invoke(i_1, ……, i_n)

函数类型变量可以使用圆括号替代调用 invoke()，但还是需要传递足够数量的参数:

#daqiKotlin.kt
fun doSometing(func :() -> Unit){
    func()
    //func.invoke()
    //run(func)
}

对于接收函数类型参数的函数，Java 8可以直接使用lambda进行调用，并且lambda会被自动转换成函数类型的值：

#daqiJava8.java
doSometing{
    
}

而对于Java 8以下的Java,需要按照函数类型的参数列表数量，选取适当的FunctionN接口，创建其匿名内部类。

#daqiJava.java
doSometing(new Function0<Unit>() {
    @Override
    public Unit invoke() {
        return Unit.INSTANCE;
    }
});

返回函数的函数

函数类型可以用作参数传递到函数中，也就意味着函数类型也能作为返回值返回，虽然这并不常用。

fun  doSometing():() -> Unit{
    return {
        
    }
}

内联函数

lambda的开销

Kotlin的lambda带来简洁语法的同时，也带来了一定的性能消耗。每一个lambda表达式会被编译成一个实现FunctionN接口的匿名类。

对于捕捉变量的lambda表达式，每次调用都是创建一个新的对象，带来额外的性能开销。对于不捕捉变量的lambda表达式，只会创建一个单例的 FunctionN 实例,并在下次调用时复用。

同时 Kotnlin 编译出来的 Function 对象没有避免对基本数据类型的装箱和拆箱(因为接收的是Object类型)。这就意味着输入值或输出值涉及到基本数据类型时，会调用系统的装箱与拆箱，造成一定的性能消耗。

(Function1)(new Function1() {

     public Object invoke(Object var1) {
        this.invoke(((Number)var1).intValue());
        return Unit.INSTANCE;
     }

     public final void invoke(int it) {
       //....
     }
})

为了生成与Java语句一样高效的代码，Kotlin提供了内联机制。对于带有inline修饰符函数，Kotlin编译器会直接将函数实现的真实代码替换每一次的函数被调用的地方。

内联的 lambda 表达式只能在内联函数内部直接调用或者作为可内联的参数传递。否则，编译器会禁止参数被内联，并给出错误信息“Illegal usage of inline-parameter”。而且内联的函数应尽量简单，比如Kotlin标准库中的内联函数总是很小的。

禁用内联

当一个lambda可能会包含很多代码，或者以不允许内联的方式使用，那么可以用 noinline 修饰符标记这些不希望内联的函数类型参数：

inline fun daqi(noinline func :() -> Unit){
    func()
}

如果一个内联函数没有可内联的函数类型参数，编译器会产生一个警告，因为这样的内联函数没意义。noinline 修饰的函数类型参数可以以任何方式操作。例如存储在字段中等等。

集合的内联操作

集合的函数式Api操作都是内联函数，所以它们的函数体都会被内联，不会产生额外的类或者对象。

#_Collections.kt
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

但序列的函数式Api中，中间操作并不是内联函数（末端操作是内联函数），所以中间操作的lambda都会被保存在字段中，等待末端操作调用由中间操作组成的调用链。

#_Sequences.kt
public fun <T> Sequence<T>.filter(predicate: (T) -> Boolean): Sequence<T> {
    return FilteringSequence(this, true, predicate)
}

internal class FilteringSequence<T>(
    private val sequence: Sequence<T>,
    private val sendWhen: Boolean = true,
    private val predicate: (T) -> Boolean
) : Sequence<T> {
}

所以，不应该总是试图将集合转化为序列，只有在处理大量数据的集合时，才需要将集合转换为序列。对于小数据量的集合，还是使用集合操作处理。