Kotlin高阶函数探究

如果一个函数接收另一个函数作为参数，或者返回类型是一个函数，那么这个函数我们就称之为高阶函数。任何以lambda或者函数引用作为参数的函数，或者返回值为lambda或函数引用的函数，都是高阶函数。

setOnClickListener的一步步省略步骤：

View(this).setOnClickListener(object: View.OnClickListener {
            override fun onClick(v: View?) {

            }
        })
        //1.单方法接口可以用lambda表达式， 省略object: View.OnClickListener
        //2.lambda表达式作为方法的最后一个参数，可以写在{}的外面


        //写为
        View(this).setOnClickListener() {

        }

        //()去掉的理由，是因为()里面没有参数，而且后面是一个lambda表达式

        //然后成了
        View(this).setOnClickListener {

        }

在参数中使用高阶函数示例：

/**
     * 加法
     */
    fun add(a: Int, b: Int): Int {
        return a + b
    }

    /**
     * 减法
     */
    fun minus(a: Int, b: Int): Int {
        return a - b
    }

    /**
     * 乘法
     */
    fun cheng(a: Int, b: Int): Int {
        return a * b
    }

/**
 * 运算
 *
 * operate:(Int, Int)->Int 表示定义的一个函数，将其作为calculate参数的形参，实际传的时候是传入add或minus函数
 */
fun calculate(a: Int, b: Int, operateType: (Int,Int) -> Int): Int {
        return operateType(a, b)
}

测试：

        Log.i("minfo", "" + calculate(12, 4, ::add))
        Log.i("minfo", "" + calculate(12, 4, ::minus))
        Log.i("minfo", "" + calculate(12, 4, ::cheng))

然后将add方法的变相写法：

/**
     * 将函数作为变量
     */
    val add1 = fun(a: Int, b: Int): Int {
        return a + b
    }
  
    //直接返回结果
    val add2 = fun(a: Int, b: Int) =  a + b

    //函数闭包写法
    val add3 = {a: Int, b: Int->
        a + b
    }

    val add4 = ::add

高阶函数作为返回值示例

//此方法的作用是如果type等于1，那么就从Num类中取出num进行乘法操作，如果不等于一，就进行相加操作
    fun getNum(type: Int): (Num) -> Int {
        if (type == 1) {
          //这是一种写法
            return { entity ->
                entity.num * entity.num
            }
        } else {
         //这是另一种简写，可以用it代替entity参数
            return {
                it.num + it.num
            }
        }
    }

首先定义了一个高阶函数，他传入三个参数，两个Int型的值和一个函数类型的值，在方法内部调用“函数类型的值”，因为它本身是函数，所以可以直接调用，并且将前两个Int型作为形参传了进去。接下来我们定义了两个函数add和minus，这两个函数实现他们本身的逻辑，最后在main函数里面调用了此高阶函数，其中::add和::minus是固定写法，表示函数的引用。

自己实现kolin自带高阶函数：

inline fun <T> Iterable<T>.myFilter(predicate:(T) -> Boolean): List<T> {
    var list = ArrayList<T>()

    for (item in this) {
        if (predicate(item)) {
            list.add(item)
        }
    }

    return list
}

inline fun <T> Iterable<T>.myForEach(handle:(T) -> Unit) {
    for (item in this) {
        handle(item)
    }
}

inline fun <T> T.myApply(handle:T.()-> Unit): T {
    handle(this)
    return this
}

inline fun <T, R> myWith(t: T, use:T.()-> R): R {
    return use(t)
}

inline fun <T, R> T.myRun(handle:T.() -> R): R {
    return handle(this)
}

测试使用：

ArrayList<User>().myApply {
            add(User("小王", 15))
            add(User("小李", 22))
            add(User("小张", 25))
        }.myFilter({
             it.age > 20
         }).myForEach({
             Log.i("minfo", it.name)
         })

        myWith(User("小王", 15)) {
            name = "哈哈"
            Log.i("minfo", name)
        }

        User("小王", 15).myRun {
            name = "修改小王为小花"
            Log.i("minfo", name)
        }

参考
Kotlin高阶函数