【Kotlin】函数式编程 ① ( 函数式编程简介 | 高阶函数 | 函数类别 | Transform 变换函数 | 过滤函数 | 合并函数 | map 变换函数 | flatMap 变换函数 )_kotlin transform

一、函数式编程简介

---

1、编程范式

编程范式 指的是 使用某种编程语言的 编程套路 或 编程习惯 ;

使用 Java 等高级语言进行的编程 , 编程范式 一般都是 面向对象编程 ;

与 面向对象编程 同等级的另外一种 编程范式 是 函数式编程 , 函数式编程 不依赖于 指定的语言 , 所有的编程语言都可以使用 函数式编程范式 ;

2、高阶函数

介绍 函数式编程 前先引入 高阶函数 的概念 , 高阶函数指的是 使用 函数类型 作为 参数 或 返回值 的函数 ;

也就是说 高阶函数 的 参数 或 返回值 是 Lambda 表达式 / 匿名函数 / 闭包 ( 三者是相同的概念 ) ;

3、函数式编程

函数式编程 主要依赖于 高阶函数 返回 的数据 , 调用 返回值 的其它函数 , 可以构建出 链式操作 , 处理复杂问题 ;

函数式编程 没有准确的 概念 , 目前使用了 链式调用 , 使用了大量的 Lambda 表达式作为 参数 或 返回值 的 高阶函数 , 就是使用了 函数式编程 范式 ;

4、前端开发技术

移动端开发 与 前端开发 使用的技术 趋于相同 , 在前端开发 ES6 ( JavaScript 标准 ECMAScript 6.0 ) 中 , 也使用 函数式编程 ;

二、函数类别

---

函数式编程 中 涉及到 三种 函数类别 :

• 变换 Transform
• 过滤 Filter
• 合并 Combine

在 函数式编程 中 , 不同类型 的 函数 可以 组合起来 , 构建复杂的操作 ;

示例 : 上述 变换 , 过滤 , 合并 三种函数类型 , 一般都是 针对 集合 设计 的 , 如 Map 集合 , 进行上述操作后 , 最终得到一个结果 ;

三、变换函数

---

变换函数 是 函数式编程 中的一种函数类型 ,

变换函数 的主要操作 是 遍历 集合中的元素 ,

变换函数 的 接收的参数 是 匿名函数 , 又称为 " 变换器函数 " , 该函数可以 对 集合中的 每个元素 进行变换操作 ,

变换完成后 , 再 将修改后的集合返回 , 然后以 供 函数式编程 调用链 中的后面的函数调用 ;

注意 : 上述操作 , 原来的集合是不改变的 ;

常见的 变换函数 :

• map 函数 , 函数原型如下 , 该函数定义在 _Collections.kt 脚本中 ;

/**
 * Returns a list containing the results of applying the given [transform] function
 * to each element in the original collection.
 * 返回一个列表，其中包含将给定的[transform]函数应用于原始集合中的每个元素的结果。
 *
 * @sample samples.collections.Collections.Transformations.map
 */
public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> {
    return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform)
}
1
2
3
4
5
6
7
8
9
10

• flatMap 函数 ; , 函数原型如下 , 该函数定义在 _Collections.kt 脚本中 ;

/**
 * Returns a single list of all elements yielded from results of [transform] function
 * being invoked on each element of original collection.
 * 返回在原始集合的每个元素上调用[transform]函数的结果所产生的所有元素的单一列表。
 */
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
    return flatMapTo(ArrayList<R>(), transform)
}
1
2
3
4
5
6
7
8

四、map 变换函数

---

1、map 函数原型分析

分析 map 函数的原型 :

public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
1

map 函数 是 Iterable<T> 集合类型 的 扩展函数 , 该扩展函数 接收的参数 是 (T) -> R 类型 的 泛型扩展匿名函数 ,

该 transform: (T) -> R 泛型扩展匿名函数 接收 T 类型参数 , 返回 R 泛型类型的 参数 ,

最终返回的集合 是由 若干 R 泛型类型 实例对象组成的 List 集合 ;

2、map 函数设计理念

作用于 Iterable<T> 集合上的 map 变换函数 , 执行后 , 原始的 Iterable<T> 类型的集合没有进行修改 ,

返回的集合是 新的 List<R> 类型的集合 ;

map 函数 返回的 List<R> 类型的集合 的 元素个数 , 与 Iterable<T> 类型的输入集合 的元素个数 是相同的 ;

map 函数 返回的 List<R> 类型的集合 的 元素类型 , 与 Iterable<T> 类型的输入集合 的元素类型 可以是不同的 ;

函数式编程 的 设计理念 就是 原始数据保持不变 , 在函数调用链上传递的是数据副本 及 修改后的信息 ;

3、代码示例

代码示例 : 首先生成了一个 字符串集合 , 然后 调用 map 函数 , 传入一个 匿名函数 , 匿名函数的类型是 (T) -> R , 其接收一个泛型 T , 也就是 遍历的字符串对象 , 然后在匿名函数中 , 进行变换操作 ;

下面调用 map 变换函数时 , 还使用了 链式调用 , 在第一个变换后的集合的基础上 , 又进行了一次变换 ;

fun main() {
    val persons = listOf("Tom", "Jerry", "Jack")
    println("原集合 persons : $persons")

    val student = persons
        .map { person -> "$person is a student" }
        .map { student -> "$student, go to school"}
    println("变换后的 persons 集合 : $persons")
    println("变换后的 student 集合 : $student")
}
1
2
3
4
5
6
7
8
9
10

执行结果 : 变换后 persons 集合 , 也就是 原集合没有发生新的变化 , 返回的集合是新创建的集合 ;

原集合 persons : [Tom, Jerry, Jack]
变换后的 persons 集合 : [Tom, Jerry, Jack]
变换后的 student 集合 : [Tom is a student, go to school, Jerry is a student, go to school, Jack is a student, go to school]
1
2
3

五、flatMap 变换函数

---

1、flatMap 函数原型分析

flatMap 函数 接收 (T) -> Iterable<R> 类型的 匿名函数 作为参数 , 返回 List<R> 类型的集合 ;

public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>
1

flatMap 函数 常用于 操作 集合 中的 集合 , 外层 集合 中 每个元素 都是一个集合 , 称为 内层集合 , 将所有 内层集合 中的元素 都展开 , 放到一个 新的集合中 , 新的集合包含了 所有 内层集合 的元素 ;

外层集合的类型 Iterable<T> , 其中 T 就是内层集合的类型 , 内层集合的类型是 Iterable<R> 类型 , 内层集合的元素类型是 R 类型 , 最终返回的结果是 List<R> 类型的集合 ;

其本质就是合并集合 ;

2、代码示例

代码示例 : 外层集合中有两个元素 , 分别是 listOf(“Tom”, “Jerry”) 集合 和 listOf(“123”, “456”) 集合 , 对外层集合使用 flatMap 变换函数 , 则可以 将两个内层集合中的元素合并起来放到一个新的集合中 ;

原来的外层集合以及内层集合不变 , 返回的 total 集合是一个新的集合 ;

此外在 flatMap 函数中可以传入 (T) -> Iterable<R> 类型的 匿名函数 作为参数 , 对内层集合进行处理 ;

fun main() {
    val total = listOf(
        listOf("Tom", "Jerry"),
        listOf("123", "456"))
        .flatMap { it }

    println(total)
}
1
2
3
4
5
6
7
8

执行结果 :

[Tom, Jerry, 123, 456]
1