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

文章目录

  • 一、函数式编程简介
  • 1、编程范式
  • 2、高阶函数
  • 3、函数式编程
  • 4、前端开发技术
  • 二、函数类别
  • 三、变换函数
  • 四、map 变换函数
  • 1、map 函数原型分析
  • 2、map 函数设计理念
  • 3、代码示例
  • 五、flatMap 变换函数
  • 1、flatMap 函数原型分析
  • 2、代码示例
  • 一、函数式编程简介


    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)
    }
    
  • 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)
    }
    

    四、map 变换函数


    1、map 函数原型分析

    分析 map 函数的原型 :

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

    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")
    }
    

    执行结果 : 变换后 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]
    

    五、flatMap 变换函数


    1、flatMap 函数原型分析

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

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

    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)
    }
    

    执行结果 :

    [Tom, Jerry, 123, 456]
    

    物联沃分享整理
    物联沃-IOTWORD物联网 » 【Kotlin】函数式编程 ① ( 函数式编程简介 | 高阶函数 | 函数类别 | Transform 变换函数 | 过滤函数 | 合并函数 | map 变换函数 | flatMap 变换函数 )

    发表评论