Kotlin高阶函数使用

Lambda表达式

说到高阶函数，不得不先接受下Lambda表达式，一个完整的lambda表达式如下：

fun main(){
    //lambda表达式
    var method03 : (Int,Int) -> Int = {
        i:Int,j:Int -> i+j
    }
    println("method03 return: ${method03(1,2)}")
}

声明method03是一个函数类型，而该函数类型的实例就是=号后面的部分，花括号包含的部分就是lambda表达式，用lambda表达式来表示一个函数类型实例

看下以下几种写法：

fun main(){
    //可以仅声明一个函数类型而没有赋值，但无法调用
    var method01 : () -> Unit
    var method02 : (Int,Int) -> Int

    //完整函数声明
    var method03 : (Int,Int) -> Int = {
        i:Int,j:Int -> i+j
    }
    println("method03 return: ${method03(1,2)}")
    
    //省略函数类型声明，在lambda表达式中可确定，返回类型根据num1 + num2推断
    var method04 = {num1 : Int, num2 : Int -> num1 + num2}
    println("method04 return: ${method04(4,2)}")
    
    //无入参和返回值
    var method05 = { println("method05：无入参和返回值")
    }
    method05()
    
    //有入参，无返回值，省略函数类型声明
    var method06 = { num1 : Int -> println("method06：$num1")}
    method06(1)
    
    //无入参，有返回值，省略函数类型声明
    var method07 = { 1 }
    println("method7 return: ${method07()}")
    
    //有入参，由于有函数类型声明，lambda内部入参可以省略类型
    var method08 :(Int) -> Unit = {
        x ->
        when (x) {
            1 -> println("这个数是1")
        }
    }
    method08(1)
    //当只有一个参数时可省略，即是lambda表达式中的it
    var method09 :(Int) -> Unit = {
        when (it) {
            2 -> println("method09：这个数是2")
        }
    }
    method09(2)
}

运行结果如下：

image.png

高阶函数

高阶函数其实就是将函数用作参数或返回值的函数，接受了前面的lambda表达式，就可以知道一个函数其实也是一个对象，函数也可以作为一个参数

先看个简单代码：

fun main(){
//    method(true,{
//        println("调用此函数")
//    })
    method(true){
        println("调用此函数")
    }
}
fun method(b: Boolean, m: () -> Unit){
    if (b) {
        m()
    }
}

注：最后一个参数是 lambda 表达式时，那么它既可作为参数在括号内传入，也可以在括号外传入
method方法接收两个参数，一个布尔类型，一个是函数类型的参数，此method即为高阶函数，代码可能很简单，并没有什么实际意义，只是为了展示高阶函数表达方式

有了上面的基础，下面看一个有意义的例子：

lateinit var adapter : Adapter
fun main(){
    val context: Context? = null
//    val adapter: Adapter = Adapter(context!!)
    val adapter: Adapter? = context?.myWith { Adapter(it) }
}
fun  T.myWith(createAdapter : (T) -> R) : R{
    return createAdapter(this)
}

上面创建一个适配器传入context，是我们Android中常用的代码，但是adapter是我们Android的，所以传入context时，编译器要求这样val adapter: Adapter = Adapter(context!!)，但这样写不太优雅，而又不想去if判空，就可以增加一个如myWith的扩展函数：

T,R泛型分别代表入参类型和返回值类型；
T.myWith是为T类型增加一个扩展函数myWith
入参是一个lambda表达式，也就是函数类型createAdapter : (T) -> R，这个函数的入参是T类型，返回值是R类型
而: R表示myWith方法的返回值也是R类型
因为myWith是T的扩展函数，调用createAdapter传入的this即是T类型，故context?.myWith { Adapter(it) }中的it即是T类型，所以createAdapter(this)返回的就是Adapter(context)，myWith返回的就是createAdapter(this)返回的结果也是Adapter(context)

最后再看一个例子：

var name: String = "xiaoming"
fun main(){
    name.let1 {
        println(it)
    }
    name.let2{
        println(this)
    }
}
fun  T.let1(m : (T) -> R) : R{
    return m(this)
}
fun  T.let2(m : T.() -> R) : R{
    return m()
}

运行结果：