当前位置：首页 > article >正文

Kotlin函数式编程与Lambda表达式

article 2025/3/4 11:16:47

Kotlin函数式编程与Lambda表达式

一、函数式编程基础

1.1 什么是函数式编程

函数式编程是一种编程范式，它将计算过程视为数学函数的求值，强调使用不可变数据和纯函数。在Kotlin中，函数式编程的特性让我们能够写出更简洁、更易维护的代码。

主要特点：

函数是一等公民
不可变性
无副作用
声明式而非命令式

1.2 为什么要使用函数式编程

// 传统命令式编程
fun calculateTotal(numbers: List<Int>): Int {
    var sum = 0
    for (number in numbers) {
        sum += number
    }
    return sum
}

// 函数式编程
fun calculateTotalFunctional(numbers: List<Int>) = numbers.sum()

函数式编程的优势：

代码更简洁
更容易测试
更好的并发性
更少的bug

二、高阶函数

2.1 高阶函数的概念

高阶函数是指可以接收函数作为参数或返回函数的函数。

// 定义一个高阶函数
fun operation(x: Int, y: Int, op: (Int, Int) -> Int): Int {
    return op(x, y)
}

// 使用高阶函数
fun main() {
    val sum = operation(4, 5) { a, b -> a + b }
    val multiply = operation(4, 5) { a, b -> a * b }
    println("Sum: $sum") // 输出：Sum: 9
    println("Multiply: $multiply") // 输出：Multiply: 20
}

2.2 常用的高阶函数

// map转换
val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map { it * 2 }

// filter过滤
val evenNumbers = numbers.filter { it % 2 == 0 }

// fold累加
val sum = numbers.fold(0) { acc, num -> acc + num }

三、Lambda表达式

3.1 Lambda表达式语法

// 基本语法
val sum = { x: Int, y: Int -> x + y }

// 类型推断
val numbers = listOf(1, 2, 3)
val doubled = numbers.map { it * 2 } // 参数it的类型被推断为Int

// 多行Lambda
val processNumber = { x: Int ->
    val doubled = x * 2
    val squared = doubled * doubled
    squared // Lambda的最后一行作为返回值
}

3.2 Lambda表达式的简化

// 完整形式
button.setOnClickListener({ view: View -> handleClick(view) })

// 如果Lambda是最后一个参数，可以移到括号外
button.setOnClickListener() { view: View -> handleClick(view) }

// 如果函数只有一个Lambda参数，可以省略空括号
button.setOnClickListener { view: View -> handleClick(view) }

// 如果Lambda只有一个参数，可以使用it
button.setOnClickListener { handleClick(it) }

// 如果Lambda直接调用某个函数，可以使用函数引用
button.setOnClickListener(::handleClick)

四、作用域函数

4.1 let、run、with、apply和also

以下是五大作用域函数的对比表格：

函数名	上下文对象	返回值	使用场景
let	it	Lambda结果	1. 处理可空对象\n2. 引入局部作用域\n3. 链式调用
run	this	Lambda结果	1. 对象配置并计算结果\n2. 多个操作需要this
with	this	Lambda结果	1. 对同一对象执行多个操作\n2. 不需要返回值
apply	this	上下文对象	1. 对象配置\n2. 返回对象本身
also	it	上下文对象	1. 链式操作\n2. 不影响原有代码块

// let：处理可空对象
val name: String? = "Kotlin"
name?.let {
    println("Name length: ${it.length}")
}

// run：对象配置并返回结果
val user = User().run {
    name = "John"
    age = 25
    email = "john@example.com"
    validate()
}

// with：对同一个对象进行多次操作
with(user) {
    println(name)
    println(age)
    println(email)
}

// apply：对象配置并返回对象本身
val user2 = User().apply {
    name = "Alice"
    age = 30
    email = "alice@example.com"
}

// also：在链式调用中添加额外操作
user2.also {
    println("Created user: ${it.name}")
}.validate()

五、实战应用

5.1 Android RecyclerView适配器优化

class UserAdapter : RecyclerView.Adapter<UserViewHolder>() {
    private var users = listOf<User>()
    private var onItemClick: ((User) -> Unit)? = null

    fun setUsers(newUsers: List<User>) = users.also { users = newUsers }

    fun setOnItemClickListener(listener: (User) -> Unit) {
        onItemClick = listener
    }

    override fun onBindViewHolder(holder: UserViewHolder, position: Int) {
        users[position].let { user ->
            holder.itemView.setOnClickListener { onItemClick?.invoke(user) }
            holder.bind(user)
        }
    }
}

5.2 网络请求处理

// 使用高阶函数处理网络请求结果
fun <T> handleApiResponse(
    response: Response<T>,
    onSuccess: (T) -> Unit,
    onError: (String) -> Unit
) {
    response.body()?.let(onSuccess) ?: response.errorBody()?.let {
        onError(it.string())
    }
}

// 使用示例
api.getUsers().enqueue(object : Callback<List<User>> {
    override fun onResponse(call: Call<List<User>>, response: Response<List<User>>) {
        handleApiResponse(
            response = response,
            onSuccess = { users -> showUsers(users) },
            onError = { error -> showError(error) }
        )
    }
})