什么是高阶函数？
高阶函数是指可以接收函数作为参数，或者返回一个函数的函数。简单来说，它让函数能够像数据一样被传递或返回，是 Kotlin 中函数式编程的核心特性。
在 Kotlin 中，函数是一等公民，这意味着你可以像操作普通变量一样操作函数，赋值、传递、返回等。
基本概念和例子
1. 函数作为参数
你可以将一个函数传递给另一个函数，用来描述行为或逻辑。
例子：简单的高阶函数
// 定义一个高阶函数，接收两个整数和一个操作函数funcalculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
return operation(a, b)
}
// 定义具体的操作函数funadd(x: Int, y: Int) = x + y
funsubtract(x: Int, y: Int) = x - y
funmain() {
// 调用高阶函数，将函数作为参数传递val result1 = calculate(5, 3, ::add) // 传递 "add" 函数val result2 = calculate(5, 3, ::subtract) // 传递 "subtract" 函数
println("Addition: $result1") // 输出: Addition: 8
println("Subtraction: $result2") // 输出: Subtraction: 2// 也可以直接传递 Lambda 表达式val result3 = calculate(5, 3) { x, y -> x * y }
println("Multiplication: $result3") // 输出: Multiplication: 15
}2. 函数作为返回值
高阶函数可以返回一个函数，从而动态地生成行为。
例子：返回一个函数
funoperation(type: String): (Int, Int) -> Int {
returnwhen (type) {
"add" -> { x, y -> x + y }
"subtract" -> { x, y -> x - y }
else -> { _, _ -> 0 }
}
}
funmain() {
val addOperation = operation("add") // 获取加法函数val subtractOperation = operation("subtract") // 获取减法函数
println(addOperation(10, 5)) // 输出: 15
println(subtractOperation(10, 5)) // 输出: 5
}3. 匿名函数与 Lambda 表达式
在 Kotlin 中，Lambda 表达式 是一种更简洁的函数定义方式。
Lambda 表达式语法：
val lambdaName: (参数类型) -> 返回类型 = { 参数 -> 函数体 }例子：
funmain() {
// Lambda 表达式val add: (Int, Int) -> Int = { x, y -> x + y }
println(add(2, 3)) // 输出: 5// 直接传递 Lambda 表达式给函数val result = calculate(10, 20) { x, y -> x * y }
println(result) // 输出: 200
}4. it 关键字
当 Lambda 表达式只有一个参数时，可以使用 it 代替显式参数。
例子：单参数的高阶函数
funmodifyString(str: String, operation: (String) -> String): String {
return operation(str)
}
funmain() {
val result = modifyString("Kotlin") { it.uppercase() } // 使用 it
println(result) // 输出: KOTLIN
}Kotlin 常见高阶函数
Kotlin 提供了很多内置的高阶函数，特别是在集合操作中。
**1. **map
将集合中的每个元素映射成另一个值。
funmain() {
val numbers = listOf(1, 2, 3, 4, 5)
val squares = numbers.map { it * it }
println(squares) // 输出: [1, 4, 9, 16, 25]
}**2. **filter
筛选出符合条件的元素。
funmain() {
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers) // 输出: [2, 4]
}**3. **reduce
从集合中聚合数据。
funmain() {
val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.reduce { acc, i -> acc + i }
println(sum) // 输出: 15
}**4. **forEach
对集合中的每个元素执行操作。
funmain() {
val numbers = listOf(1, 2, 3)
numbers.forEach { println(it) }
}简化日常开发的高阶函数
**1. 空安全操作符 ?. 和 **?:
虽然看起来简单，但本质上利用了高阶函数的思想。
?.：如果对象不为null，就执行后续操作。?:：提供一个默认值。
funmain() {
val name: String? = null// ?. 避免空指针异常
println(name?.uppercase()) // 输出: null// ?: 提供默认值
println(name?.uppercase() ?: "默认值") // 输出: 默认值
}**2. 结合 let 和 **run
let 和 run 是常用的高阶函数，主要用于避免重复写判断逻辑。
funmain() {
val name: String? = "Kotlin"// 使用 let：只在不为 null 时操作
name?.let {
println("Name is not null: $it")
}
// 使用 run：可以对对象进行一系列操作val result = name?.run {
this.uppercase()
}
println(result) // 输出: KOTLIN
}总结
- 高阶函数的特点：
- 函数可以作为参数。
- 函数可以作为返回值。
- 简化代码，增强代码的灵活性。
- 高阶函数的应用：
- 用于操作集合（如
map,filter等）。 - 简化业务逻辑（如
let,apply,run等）。 - 替代传统回调方法。
- 用于操作集合（如
- 与 Java 的区别：
- 在 Java 中，高阶函数通常通过匿名类实现，代码复杂。
- Kotlin 提供了简洁的语法支持（如 Lambda 表达式），让高阶函数的使用更加方便。
学会高阶函数后，Kotlin 的代码将更加简洁且优雅！
问题
Kotlin 的高阶函数是不是 Java 中的 Lambda 表达式？
高阶函数 是指能够接收函数作为参数或者返回函数的函数。
- Kotlin 中的高阶函数用法与 Java 8 中的 Lambda 表达式类似，但 Kotlin 在语言层面上对高阶函数的支持更好，语法更加简洁和灵活。
- 在 Kotlin 中，你不仅可以传入 lambda 表达式，还可以直接用函数类型作为变量或参数类型，这在 Java 中往往需要借助接口或匿名内部类实现。
举个例子，在 Kotlin 中定义一个高阶函数：
fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
return operation(a, b)
}
val sum = operate(3, 4) { x, y -> x + y }
println(sum) // 输出 7在 Java 中，你可能需要写成下面这样（使用 Function 接口）：
// Java 8 示例
public int operate(int a, int b, BiFunction<Integer, Integer, Integer> operation) {
return operation.apply(a, b);
}
int sum = operate(3, 4, (x, y) -> x + y);总体上，Kotlin 的写法更直接，语法也更灵活，虽然初看可能会觉得不习惯，但习惯后会觉得代码更简洁、表达力更强。
更新: 2025-03-24 11:58:46
原文: https://www.yuque.com/dongpozhouzi-mshe3/zhm85g/zwp0twvtdwaepyqm