函数与函数式编程
函数式编程与命令式编程最大的不同是：函数式编程的焦点在于数据的映射，命令式编程（imperative programming）的焦点是解决问题的步骤。
函数式编程和命令式编程比较
fun main() {
val list = listOf<Int>(1, 2, 3, 4, 5)
// 函数式编程
println(list.filter { it % 2 == 0 })
// 命令式编程
for (i in list) {
if (i % 2 == 0)
println(i)
}
}
如果式Java的话，还要写for(;;)遍历，函数式编程就显得可读性更好了。
1. 函数式编程
- 一等函数支持（first-class function）：函数也是一种数据类型，可以作为参数传入另一个函数中，同时函数也可以返回一个函数。
- 纯函数（pure function）和不变性（immutable）：纯函数指的是没有副作用的函数（函数不去改变外部的数据状态）。例如，一个编译器就是一个广义上的纯函数。在函数式编程中，倾向于使用纯函数编程。正因为纯函数不会去修改数据，同时又使用不可变的数据，所以程序不会去修改一个已经存在的数据结构，而是根据一定的映射逻辑创建一份新的数据。函数式编程是转换数据而非修改原始数据。
- 函数的组合（compose function）：在面向对象编程中是通过对象之间发送消息来构建程序逻辑的；而在函数式编程中是通过不同函数的组合来构建程序逻辑的。
2. 声明函数
fun sum(v1: Int, v2: Int): Int {
return v1 + v2
}
val sum = fun(v1: Int, v2: Int): Int { return v1 + v2 }
3. Lambda表达式
val list = listOf(1, 2, 3, 4, 5, 6, 7)
list.filter { it % 2 == 1 }
因为filter函数只有一个参数所以小括号被省略了
list.filter ({ it % 2 == 1 })
而filter函数的参数式一个函数，参数类型式predicate: (T) -> Boolean
{ it % 2 == 1 } 是一个简写的Lambda表达式
{ it -> it % 2 == 1 } //实际的Lambda 表达式
完整的写法是
val odd = {it:Int -> it % 2 == 1}
list.filter(odd)
可以看一下filter的源码
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
return filterTo(ArrayList<T>(), predicate)
}// predicate 是传入的函数，调用filterTo方法
// filterTo方法中使用了predicate判断是否满足条件
// 如果满足条件则加入destination 容器里面
public inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C {
for (element in this) if (predicate(element)) destination.add(element)
return destination
}
4. 高阶函数
val f = fun(x: Int) = x % 2 == 1
val g = fun(s: String) = s.length
val h = fun(g: (String) -> Int, f: (Int) -> Boolean): (String) -> Boolean {
return { f(g(it)) } // {}表示返回的是lambda表达式，如果没有返回的是boolean值了
}
val strs = listOf("a", "ab", "abc", "abcd")
println(strs.filter( h(g, f) ))
使用typealias别名简化
typealias G = (String) -> Int
typealias F = (Int) -> Boolean
typealias H = (String) -> Boolean
val h = fun(g: G, f: F): H {
return { f(g(it)) } //需要注意的是，这里的{} 是不能省略的
}
image.png
5. kotlin中特殊函数
kotlin包下的Standard.kt 文件中定义的方法
run()、apply()、let()、also()和with()、takeIf、takeUnless、repeat
1. run()
定义
public inline fun <R> run(block: () -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block()
}
使用
fun myfun(): String {
println("执行了myfun 函数")
return "这是myfun 的返回值"
}
fun main() {
myfun()
run({ myfun() })
run { myfun() }
run { println("A") }
}
结果
执行了myfun 函数
执行了myfun 函数
执行了myfun 函数
A
2. apply()函数
定义
public inline fun <T> T.apply(block: T.() -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block()
return this
}
使用
val list = ArrayList<String>().apply {
add("1")
add("2")
add("3")
}
println(list)
结果
[1, 2, 3]
3. let()函数
定义
public inline fun <T, R> T.let(block: (T) -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return block(this)
}
使用
list.let { println(it) }
结果
[1, 2, 3]
4. also()函数
定义
public inline fun <T> T.also(block: (T) -> Unit): T {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
block(this)
return this
}
使用
fun testAlsoFun() {
val a = "ABC".also {
println(it) //输出：ABC
}
println(a) //输出：ABC
a.let {
println(it) //输出：ABC
}
}
结果
ABC
ABC
ABC
5. with()函数
定义
public inline fun <T, R> with(receiver: T, block: T.() -> R): R {
contract {
callsInPlace(block, InvocationKind.EXACTLY_ONCE)
}
return receiver.block()
}
使用
with(ArrayList<Int>()){
add(1)
add(2)
add(3)
}.let { println(it) }
结果
1
2
3
