1,基本定义
什么是高阶函数?
高阶函数定义：参数有函数类型或者返回值是函数类型的函数。
在Kotlin中增加了一个函数类型的概念，如果我们将这种函数添加到一个函数的参数声明或返回值声明当中，那么这就是一个高阶函数了。
2,如何定义高阶函数
函数类型语法基本规则：
函数类型定义：
(String, Int) -> Unit
添加到某个函数的参数声明,那么该函数称之为高阶函数了
fun example(func:(String,Int) -> Unit){
func("Hello",666)
}
例子2参数有函数类型
fun a(funParam: (Int) -> String): String {
return funParam(1)
}
3,高阶函数的使用
高阶函数有三种用法
- 双冒号 ::method
- 匿名函数
- Lambda 表达式
定义一个高阶函数
fun num1AndNum2(num1: Int, num2: Int, operation: (Int, Int) -> Int): Int {
val result = operation(num1, num2)
return result
}
双冒号 ::method形式的用法
fun plus(num1: Int, num2: Int): Int {
return num1 + num2
}
fun main() {
val value = num1AndNum2(10, 8, ::plus)
println(value)
//打印结果:18
}
匿名函数形式的用法
fun main() {
val value = num1AndNum2(10, 8, fun(num1: Int, num2: Int) = num1 + num2)
println(value)
//打印结果:18
}
Lambda 表达式形式的用法
fun main() {
val value = num1AndNum2(10, 8) { n1, n2 ->
n1 + n2
}
println(value)
//打印结果:18
}
4,系统常用的高阶函数
-
map
操作集合中数据,遍历原有集合,生成一个新的集合.
通常方式
fun main() {
val list = listOf(1, 3, 4, 5, 10, 8, 2)
val newList = ArrayList()
list.forEach {
val element = it * 2 + 3
newList.add(element)
}
newList.forEach(::println)
}
使用高阶函数map
fun main() {
val list = listOf(1, 3, 4, 5, 10, 8, 2)
val newList = list.map {
it * 2 + 3
}
newList.forEach(::println)
}
-
flatMap
嵌套遍历集合,生成新的集合.
例1
fun main() {
val list = listOf(1..8,
2..5,
10..15)
val flatList = list.flatMap {
it.map { number ->
"No.$number"
}
}
flatList.forEach(::println)
}
例2
fun main() {
val list = mutableListOf(
arrayOf("华晨宇", "张碧晨", "邓紫棋"),
arrayOf("何老师", "汪涵"),
arrayOf("谢娜", "张杰", "汪诗诗"),
)
val flatList = list.flatMap {
it.map { name ->
"大明星:$name"
}
}
flatList.forEach(::println)
}
-
reduce
从第一个元素开始累加值，并将操作从左到右应用到当前累加器值和每个元素。
例1,迭代求和
fun main() {
val list = listOf(1, 2, 5, 2)
println(list.reduce { acc, i ->
println("acc:$acc,i:$i")
acc + i
})
}
结果:
acc:1,i:2
acc:3,i:5
acc:8,i:2
10
列2,使用,莲姐字符串操作
fun main() {
val list = listOf("华晨宇", "张碧晨", "邓紫棋")
val result = list.reduce { acc, element ->
"$acc,$element".also {
println("acc:$acc")
println("element$element")
println(it)
}
}
println("result:$result")
}
-
fold
这个函数和reduce类似，不过它可以设置一个初始值
例1:
fun main() {
val result = (0..6).fold(StringBuilder()) { acc, i ->
acc.append(i).append(",")
}
println("result:$result")
//result:0,1,2,3,4,5,6,
}
例2:
fun main() {
val result = (0..3).fold(10) { acc, i ->
acc + i
}
println("result:$result")
//result:16
}
例3:
fun main() {
val list = listOf(UserEntity(100, "华晨宇", 30),
UserEntity(101, "张碧晨", 31),
UserEntity(103, "邓紫棋", 29))
val result = list.fold(0) { acc, next ->
(acc + next.age).also {
println("acc:$it")
}
}
println("result:$result")
}
结果
acc:30
acc:61
acc:90
result:90
-
joinToString
例1
fun main() {
val result = (0..6).joinToString(",")
println("result:$result")
}
result:0,1,2,3,4,5,6
例2
fun main() {
val list = listOf(701,702,703,705)
val result = list.joinToString(",")
println("result:$result")
}
//result:701,702,703,705
例3
fun main() {
val list = listOf(UserEntity(100, "华晨宇"),
UserEntity(101, "张碧晨"),
UserEntity(103, "邓紫棋"))
val result = list.joinToString(",") {
it.userId.toString()
}
println("result:$result")
}
//result:100,101,103
-
filter
过滤一个符合条件新的集合出来.
fun main() {
val list = listOf(UserEntity(100, "华晨宇", 30),
UserEntity(101, "张碧晨", 31),
UserEntity(103, "邓紫棋", 29))
val result = list.filter {
it.age >= 30
}
println("result:$result")
//result:[userName:华晨宇,userId:100,age:30, userName:张碧晨,userId:101,age:31]
}
-
takeWhile
遇到第一个不符合条件的就结束，留下前边的作为一个新的集合返回.
fun main() {
val list = listOf(
UserEntity(100, "华晨宇", 30),
UserEntity(101, "张碧晨", 31),
UserEntity(103, "邓紫棋", 29),
UserEntity(103, "李宇春", 32),
)
val result = list.takeWhile {
it.age >= 30
}
println("result:$result")
//result:[userName:华晨宇,userId:100,age:30, userName:张碧晨,userId:101,age:31]
}
5,看清高阶函数的本质
高阶函数就是多阶映射。高阶函数用另一个函数作为其输入参数，也可以返回一个函数作为输出。