kotlin - Lambda表达式高阶函数的使用

Android_Banner.jpg

简介

• Lambda表达式可以作为函数的实际参数或者返回值存在，这种声明，在kotlin中叫做高阶函数
• 将Lambda表达式作为参数或返回值，会大大简化程序开发时的代码，提高程序开发的效率

函数作为参数使用

• Lambda表达式除了定义在方法的内部，还可以作为函数的实参
• 测试代码

/**
     * 这是用来测试Lambda作为参数的测试
     */
    private fun testAsParameter() {
        //定一个Int数组
        val list = 1..20

        // 筛选能被5整除的
        println("==========================")

        println(list.pickNUm({ x: Int -> x % 5 == 0 }))

        //筛选能被10整除的

        println("==========================")

        println(list.pickNUm({ y: Int -> y % 10 == 0 }))
    }
    
     /**
     * function: (Int) -> Boolean
     *
     * function: 形式参数名，可以任意修改
     *
     * (Int) -> Boolean 形式参数类型 这里描述的是一个函数类型，函数的参数是Int类型 函数的返回值是Boolean类型的
     */
    private fun IntRange.pickNUm(function: (Int) -> Boolean): List<Int> {

        //声明一个集合
        val resultList = mutableListOf<Int>()

        // this 指向定义的区间范围（IntRange）
        for (i in this) {
            if (function(i)) {
                resultList.add(i)
            }
        }
        return resultList
    }

• 运行结果

2020-08-02 15:16:30.953 17661-17661/com.dashingqi.module.lambda I/System.out: ==========================
2020-08-02 15:16:30.953 17661-17661/com.dashingqi.module.lambda I/System.out: [5, 10, 15, 20]
2020-08-02 15:16:30.953 17661-17661/com.dashingqi.module.lambda I/System.out: ==========================
2020-08-02 15:16:30.953 17661-17661/com.dashingqi.module.lambda I/System.out: [10, 20]

函数作为参数的优化

• 当Lambda作为函数参数使用时，还有3种优化形式，分别是
  • 省略小括号
  • 将参数移动到小括号外面
  • 使用it关键字

省略小括号

• 当函数只有一个参数，并且这个参数是一个函数类型，那么在调用函数的时候可以去掉函数名称后面小括号
• 测试代码

/**
     * function: (Int) -> Boolean
     *
     * function: 形式参数名，可以任意修改
     *
     * (Int) -> Boolean 形式参数类型 这里描述的是一个函数类型，函数的参数是Int类型 函数的返回值是Boolean类型的
     */
    private fun IntRange.pickNUm(function: (Int) -> Boolean): List<Int> {

        //声明一个集合
        val resultList = mutableListOf<Int>()

        // this 指向定义的区间范围（IntRange）
        for (i in this) {
            if (function(i)) {
                resultList.add(i)
            }
        }
        return resultList
    }
    
  /**
     * 这是用来测试Lambda作为参数的测试
     */
    private fun testAsParameter() {
        //定一个Int数组
        val list = 1..20
        //筛选能被10整除的
        println("==========================")
        //省略之前
        println(list.pickNUm({ y: Int -> y % 10 == 0 }))
        //省略之后
        println(list.pickNUm { y: Int -> y % 10 == 0 })
    }

• 在上述代码中，pickNum中只有一个参数，并且这个参数时函数型的，所以在调用函数时，可以省略函数名称后面的小括号，直接使用 pivkNum{y:Int->y%10==0}

将参数移动到小括号外面

如果一个函数有多个参数，但是最后一个参数类型是函数类型，那么在调用函数的时候，可以将最后一个参数从括号中移出。

• 测试代码

    /**
     * 这是用来测试Lambda作为参数的测试
     */
    private fun testAsParameter() {
        //定一个Int数组
        val list = 1..20
        println("==========================")
        //将参数移动到小括号外面之前
        println(list.pickNUm(1, { y: Int -> y % 10 == 0 }))
        //将参数移动到小括号外面之后
        println(list.pickNUm(2) { y: Int -> y % 10 == 0 })
    }

    /**
     * function: (Int) -> Boolean
     *
     * function: 形式参数名，可以任意修改
     *
     * (Int) -> Boolean 形式参数类型 这里描述的是一个函数类型，函数的参数是Int类型 函数的返回值是Boolean类型的
     */
    private fun IntRange.pickNUm(need: Int, function: (Int) -> Boolean): List<Int> {

        //声明一个集合
        val resultList = mutableListOf<Int>()

        // this 指向定义的区间范围（IntRange）
        for (i in this) {
            if (function(i)) {
                resultList.add(i)
            }
        }
        return resultList
    }

• 上述代码中，pickNum()函数中，有两个参数，最后一个参数是函数类型的，当调用函数的时候，可以将函数类型的参数移动到小括号之外（也就是lambda表达式移动到小括号之外），也就变成了 list.pickNum(1){y:Int->y%10==0}

使用it关键字

无论函数包括多少个参数，如果其中有参数是函数类型，并且函数类型满足仅仅接受一个参数的要求，可以用it关键字代替函数的形参以及箭头

• 测试代码

  /**
     * 这是用来测试Lambda作为参数的测试
     */
    private fun testAsParameter() {
        //定一个Int数组
        val list = 1..20
        //筛选能被10整除的
        println("==========================")
        //没有使用it关键字之前
        println(list.pickNUm(2) { y: Int -> y % 10 == 0 })
        //使用关键字之后
        println(list.pickNUm(2) { it % 10 == 0 })
    }

    /**
     * function: (Int) -> Boolean
     *
     * function: 形式参数名，可以任意修改
     *
     * (Int) -> Boolean 形式参数类型 这里描述的是一个函数类型，函数的参数是Int类型 函数的返回值是Boolean类型的
     */
    private fun IntRange.pickNUm(need: Int, function: (Int) -> Boolean): List<Int> {

        //声明一个集合
        val resultList = mutableListOf<Int>()

        // this 指向定义的区间范围（IntRange）
        for (i in this) {
            if (function(i)) {
                resultList.add(i)
            }
        }
        return resultList
    }

• 上述代码中，pickNum(need:Int,function:(Int) -> Boolean)函数包含两个参数，其中“function:(Int)->Boolean”参数是函数类型并且仅仅接受一个参数，因此在调用函数时，可以使用it关键字来代替函数的形参以及箭头，也就是 list.pickNum(1){it % 10 == 0}

函数作为返回值

• 函数不仅可以作为参数使用，还可以作为返回值使用。
• 测试代码

fun testAsReturnValue() {
        val normalPrice = getPrice(USER.NORMAL)(400.0)
        println("normalPrice ----> $normalPrice")

        val vipPrice = getPrice(USER.VIP)(400.0)
        println("vipPrice ----> $vipPrice")
    }

    /**
     * lambda表达式作为返回值
     */
    private fun getPrice(userType: USER): (Double) -> Double {

        if (userType == USER.NORMAL) {
            return { it }
        }

        return { price -> 0.88 * price }

    }

• 针对 (Double) -> Double
• (Double) 是作为lambda表达式参数类型
• -> Double 是作为函数的返回值类型也就是 getPrice()