Higher-Order Function（高阶函数）

4. 高阶函数（Higher-Order Function）

核心定义

满足以下任一条件的函数：

  1. 接收一个或多个函数类型作为参数；
  2. 返回值类型是函数类型。

关键特征

  • 函数类型语法：(参数列表) -> 返回值（如(Int, Int) -> Int、() -> Unit）；
  • 支持函数引用（::函数名）、lambda 表达式、匿名函数作为参数 / 返回值；
  • 结合内联函数使用可避免性能损耗。

使用场景

  • 提取通用逻辑，注入可变部分（如calculate函数，注入加减乘除逻辑）；
  • 函数式编程（如集合的map、filter、reduce）；
  • 回调函数（替代 Java 的匿名内部类）；
  • 返回函数类型实现 “函数工厂”（如创建不同的计算器函数）。

示例

// 示例1：接收函数类型参数（通用计算逻辑）
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 示例2：返回函数类型（函数工厂）
fun createOperator(operator: String): (Int, Int) -> Int {
    return when (operator) {
        "+" -> { a, b -> a + b }
        "*" -> { a, b -> a * b }
        else -> { _, _ -> 0 }
    }
}

// 使用
fun main() {
    // 传入lambda作为参数
    val sum = calculate(10, 20) { a, b -> a + b }
    val mul = calculate(10, 20) { a, b -> a * b }
    println(sum) // 30
    println(mul) // 200
    
    // 调用返回的函数
    val addFunc = createOperator("+")
    println(addFunc(5, 5)) // 10
}

注意事项

  • 非内联的高阶函数会创建闭包对象，可能导致额外的内存开销；
  • 函数类型参数默认是final，不能在内部修改外部变量（除非用var或mutable类型）。

高阶函数

高级函数的核心特征：接收函数类型参数 或 返回函数类型；

核心前提：函数类型用于描述函数的签名（(参数列表) -> 返回值）；

两种常见形式：接收函数参数（最常用）、返回函数类型；

核心价值：提高代码复用性、灵活性，支撑函数式编程；

Kotlin 标准库内置大量高级函数，是日常开发的重要工具。

核心定义

在 Kotlin 中，高级函数是指满足以下两个条件之一的函数（二者满足其一即可，也可同时满足）：

  1. 接受一个或多个函数类型作为参数（把函数当作 “参数” 传递给另一个函数）；
  2. 返回值类型是一个函数类型（把函数当作 “返回结果” 返回给调用者）。

简单来说：高级函数打破了 “函数只能操作数据” 的限制，让函数可以作为另一个函数的输入（参数）或输出（返回值），这是函数式编程的核心特征。

核心前提：理解「函数类型」

要掌握高级函数，首先要理解「函数类型」—— 它是用来描述 “函数的签名” 的类型，就像Int描述整数、String描述字符串一样，函数类型描述函数的 “参数列表” 和 “返回值”。

函数类型的语法格式

// 格式1：无参数、有返回值（返回值为Int）
() -> Int

// 格式2：有参数、有返回值（参数为两个Int，返回值为Int）
(Int, Int) -> Int

// 格式3：有参数、无返回值（无返回值用Unit表示，等价于Java的void）
(String) -> Unit

关键说明

  • 箭头左边是参数列表：多个参数用逗号分隔，无参数留空括号()；
  • 箭头右边是返回值类型：无论函数是否有返回值，都必须指定（无返回值必须写Unit，不能省略）；
  • 函数类型可以作为参数类型、返回值类型，这是高级函数的基础。

高级函数的两种核心形式（代码示例）

形式 1：接受函数类型作为参数（最常用）

这种高级函数接收一个或多个函数作为参数，在内部可以调用该传入的函数，实现 “逻辑注入”—— 即函数的核心流程固定，具体逻辑由传入的函数决定。

// 定义高级函数：接收两个Int参数，和一个(Int, Int) -> Int类型的函数参数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    // 内部调用传入的函数参数，执行具体逻辑
    return operation(a, b)
}

// 定义两个普通函数，用于传递给高级函数（符合(Int, Int) -> Int的函数类型）
fun add(x: Int, y: Int): Int = x + y
fun multiply(x: Int, y: Int): Int = x * y

fun main() {
    // 调用高级函数：传递add函数作为参数，实现加法逻辑
    val sumResult = calculate(10, 20, ::add)
    println("加法结果：$sumResult") // 输出：加法结果：30

    // 调用高级函数：传递multiply函数作为参数，实现乘法逻辑
    val mulResult = calculate(10, 20, ::multiply)
    println("乘法结果：$mulResult") // 输出：乘法结果：200

    // 简化写法：直接传递lambda表达式（无需提前定义普通函数）
    val subResult = calculate(10, 20) { x, y -> x - y }
    println("减法结果：$subResult") // 输出：减法结果：-10
}

关键说明：

  • ::add 是 Kotlin 中的「函数引用」，用于将已定义的普通函数转换为函数类型，满足高级函数的参数要求；
  • 当高级函数的最后一个参数是函数类型时，可以将 lambda 表达式移到括号外（称为 “尾随 lambda”），让代码更简洁。
形式 2：返回值是函数类型

这种高级函数本身执行后，会返回一个新的函数，后续可以调用这个返回的函数来完成具体逻辑。

// 定义高级函数：返回值类型是 (Int) -> Int（接收一个Int，返回一个Int）
fun createMultiplier(factor: Int): (Int) -> Int {
    // 返回一个lambda表达式（符合(Int) -> Int的函数类型）
    return { num -> num * factor }
}

fun main() {
    // 步骤1：调用高级函数，返回一个“乘以2”的函数
    val doubleFunc = createMultiplier(2)
    // 步骤2：调用返回的函数，执行具体逻辑
    val doubleResult = doubleFunc(10)
    println("10乘以2的结果：$doubleResult") // 输出：10乘以2的结果：20

    // 步骤1：调用高级函数，返回一个“乘以3”的函数
    val tripleFunc = createMultiplier(3)
    // 步骤2：调用返回的函数，执行具体逻辑
    val tripleResult = tripleFunc(10)
    println("10乘以3的结果：$tripleResult") // 输出：10乘以3的结果：30

    // 链式调用（简化写法）
    val result = createMultiplier(5)(20)
    println("20乘以5的结果：$result") // 输出：20乘以5的结果：100
}

关键说明：

  • 高级函数createMultiplier的返回值类型是(Int) -> Int，它内部返回的 lambda 表达式必须匹配该函数类型；
  • 变量doubleFunc、tripleFunc本质上是 “函数对象”，可以像普通函数一样调用（加括号传参）；
  • 链式调用createMultiplier(5)(20)：先执行createMultiplier(5)返回一个函数，再用这个函数接收参数20执行。

高级函数的核心价值（为什么要用？）

  1. 提高代码复用性：提取固定流程作为高级函数的核心逻辑，将变化的逻辑以函数参数的形式注入，避免重复编写相似代码（如上面的calculate函数，复用了 “接收两个数、执行运算、返回结果” 的流程，加法、乘法、减法逻辑可灵活替换）；
  2. 增强代码灵活性：支持动态注入逻辑，让函数的行为更灵活，适应不同场景的需求；
  3. 支撑函数式编程：是 Kotlin 中 lambda 表达式、集合操作（map、filter、reduce等）的底层基础，比如list.map { it * 2 }中的map就是一个高级函数；
  4. 简化代码书写：结合 lambda 表达式，可以大幅简化代码，让代码更简洁、更具可读性。

补充：Kotlin 内置的高级函数示例

Kotlin 的标准库中提供了大量内置高级函数，日常开发中经常用到，比如：

  1. 集合操作函数：map、filter、reduce、forEach
fun main() {
    val list = listOf(1, 2, 3, 4, 5)
    
    // map 是高级函数，接收一个(Int) -> Any类型的函数参数
    val doubledList = list.map { it * 2 }
    println("翻倍后的列表：$doubledList") // 输出：翻倍后的列表：[2, 4, 6, 8, 10]
    
    // filter 是高级函数，接收一个(Int) -> Boolean类型的函数参数
    val evenList = list.filter { it % 2 == 0 }
    println("偶数列表：$evenList") // 输出：偶数列表：[2, 4]
}
  1. 作用域函数：let、run、with、apply、also（均为高级函数）
fun main() {
    val str = "HelloKotlin"
    
    // let 是高级函数，接收一个(String) -> Unit类型的函数参数
    str.let {
        println("字符串长度：${it.length}")
        println("字符串转大写：${it.uppercase()}")
    }
}
最近更新：:
Contributors: luokaiwen