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()
网友评论