【Kotlin】函数式编程 ② ( 过滤函数 | predicate 谓词函数 | filter 过滤函数 | 合并函数 | zip 函数 | folder 函数

函数式编程的三种函数类别 :

变换 Transform
过滤 Filter
合并 Combine

在上一篇博客 函数式编程 ① 中讲解了变换函数 map 函数与 flatMap 函数 , 本篇博客中着重讲解过滤函数和合并函数 ;

一、过滤函数

过滤函数是函数式编程中的函数类型 , 一般该类型函数接收一个 Predicate 谓词函数作为参数 ;

该 谓词函数 参数是一个 Lambda 表达式 / 匿名函数 / 闭包 ; ( 三者是同一个概念 )

过滤函数 的接收者是一个集合 , 也就是说过滤函数要从接收者集合中过滤掉一些元素 , 生成一个新的集合 ;

谓词函数 主要是按照一定的逻辑条件 , 判断接收者集合中的元素是否符合某种条件 , 如果符合返回 true , 不符合条件返回 false ;

谓词函数返回 true , 将该元素添加到新的集合中 ;
谓词函数返回 false , 该函数不能被添加到新的集合中 ;

注意 : 过滤函数会返回一个新的集合 , 原来的接收者集合不会发生改变 ;

二、filter 函数原型

filter 函数原型 :


/**
 * Returns a list containing only elements matching the given [predicate].
 * 返回只包含匹配给定[predicate]的元素的列表。
 * @sample samples.collections.Collections.Filtering.filter
 */
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}

该过滤函数 filter 函数 , 是集合类型的扩展函数 , 集合的元素类型是泛型 T , 可以是任意类型 ;

filter 函数的参数 predicate: (T) -> Boolean 谓词函数 , 是匿名函数 , 用于判断接收者集合中的受检元素是否符合该匿名函数的要求 ,

如果该元素符合要求 , 该匿名函数返回 true , 将该接收者集合中的受检元素放到返回值集合 List<T> 中 ;
如果该元素不符合要求 , 该匿名函数返回 false , 该接收者集合中的受检元素不会放到返回值集合 List<T> 中 , 相当于被过滤掉了 ;

三、filter 过滤函数代码示例

1、filter 函数简单示例

代码示例 :

fun main() {
    // 过滤 接收者集合 中 含有字母 "J" 的字符串元素
    val hasJCharacter = listOf("Tom", "Jerry", "Jack")
                        .filter { it.contains("J") }

    println(hasJCharacter)
}

执行结果 :

[Jerry, Jack]

kotlin filter,Kotlin,kotlin,函数式编程,过滤函数,合并函数,谓词函数

2、filter 过滤函数与 flatMap 变换函数组合使用示例

代码示例 :

先使用 flatMap 变换函数 , 将集合的集合拉平 , 在 flatMap 函数的闭包参数中的 it 是返回的是集合元素 ,
然后针对该集合调用 filter 过滤函数 , 将其中包含 J 字幕的元素过滤出来 ,
最终得到的集合是先将两个集合合并 , 然后再过滤包含 J 的元素的新集合 ;

fun main() {
    // 过滤 接收者集合 中 含有字母 "J" 的字符串元素
    val hasJCharacter = listOf(listOf("Tom", "Jerry", "Jack"), listOf("Julia", "June", "John"))
                        .flatMap { it.filter { it.contains("J") } }

    println(hasJCharacter)
}

执行结果 :

[Jerry, Jack, Julia, June, John]

kotlin filter,Kotlin,kotlin,函数式编程,过滤函数,合并函数,谓词函数

如果要在 Java 中实现上述功能 , 需要设置双重循环 , 外层循环遍历外层集合 , 内层循环遍历内层集合 ;

在 Kotlin 中使用函数式编程实现 , 仅需要 1 行代码 ;

3、filter 过滤函数与 map 变换函数组合使用示例

找出 2 到 10 之间的质数 ; 质数是大于 1 并且只有 1 和其本身可以被其整除 ;

代码示例 :

执行 numbers.filter{} 代码 , 如果匿名函数参数返回 true , 则为质数 , 该匿名函数的参数 number 是被遍历的接收者集合的受检元素 ;
判定质数 , 就需要根据 " 质数只有 1 和其本身可以被其整除 " 的原理进行判定 , 遍历时每个受检元素都要被 [2…number - 1] 区间的数值进行遍历 , 使用 (2..number - 1).map{} 进行遍历 , 计算 number 与 [2…number - 1] 区间中的数值相除的余数 , 确保这些余数不为 0 即可 ;
上面的 map 变换函数会返回一个余数集合 , 调用该余数集合的 .none{it == 0} 函数 , 确保余数中不会有 0 , 没有 0 则返回 true , 说明余数都不为 0 , [2…number - 1] 区间的数值都不能被整除 , 该数值为质数 ;

fun main() {
    // 找出 2 到 10 之间的 质数
    // 质数只有 1 和 其本身 可以被其整除
    val numbers = listOf(2, 3, 4, 5, 6, 7, 8, 9, 10)
    val primeNumbers = numbers.filter { number ->
        // number 参数是被遍历的 接收者集合 的 受检元素
        // 符合下面的要求 才会被放入新集合
        // 遍历时每个 受检元素 都要 被 [2..number - 1] 区间的数值进行遍历
        (2..number - 1)
            // 计算 number 与 [2..number - 1] 区间中的数值 相除的 余数
            // 也就是验证 是否 只有 1 和 其本身 可以被其整除
            .map { number % it }
            // 通过 map 变换计算出的余数
            // 不能出现 余数 为 0 的情况
            // 一旦出现 就返回 false
            .none{it == 0}
    }
    println(primeNumbers)
}

执行结果 : 最终得到如下几个质数 ;

[2, 3, 5, 7]

kotlin filter,Kotlin,kotlin,函数式编程,过滤函数,合并函数,谓词函数

上述判定质数的操作 , 使用 Kotlin 代码只需要一行链式调用代码搞定 , 如果是 Java 代码 , 要写好多循环 , 至少 50 行代码 ;

使用 Kotlin Bytecode 将字节码反编译会 Java 代码如下 : 可以看到有几十行代码 , 使用 Java 代码实现很复杂 ;

kotlin filter,Kotlin,kotlin,函数式编程,过滤函数,合并函数,谓词函数

none 函数原型 : 接收者集合调用 none 函数 , 传入谓词匿名函数参数返回布尔值 , 如果所有的接收者集合元素对应的匿名函数参数都返回 false , 则整体返回 true ;

/**
 * Returns `true` if no elements match the given [predicate].
 * 如果没有元素匹配给定的[谓词]，则返回' true '。
 * @sample samples.collections.Collections.Aggregates.noneWithPredicate
 */
public inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean {
    if (this is Collection && isEmpty()) return true
    for (element in this) if (predicate(element)) return false
    return true
}

四、合并函数

合并函数是函数式编程的一种函数类型 , 该类型函数的作用是将不同的集合合并成新的集合 ;

1、zip 合并函数

zip 函数可以将两个元素个数相同的集合合并成一个新的 Pair 键值对 List 集合 , 其中一个集合的元素作为键 Key , 另外一个集合的元素作为值 Value ;

被合并的两个集合可以是不同类型的集合 ;

zip 组合函数原型 :

/**
 * Returns a list of pairs built from the elements of `this` collection and [other] collection with the same index.
 * The returned list has length of the shortest collection.
 * 返回由具有相同索引的' this '集合和[other]集合的元素构建的对列表。
 * 返回的列表长度为最短的集合。
 * @sample samples.collections.Iterables.Operations.zipIterable
 */
public infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>> {
    return zip(other) { t1, t2 -> t1 to t2 }
}

zip 函数 是为 Iterable<T> 集合类型定义的扩展函数 , 该集合的元素类型为 T 泛型 , 可以是任意类型 , 该接收者集合中的元素最终会作为 List<Pair<T, R>> 集合中 Pair 实例的键 Key ;

该 zip 函数的参数是 Iterable<R> 类型 , 集合元素类型 R 泛型 , 可以与 T 泛型是同一个类型 , 也可以是不同的类型 ;

最终返回的类型是 List<Pair<T, R>> 键值对集合 ;

由于 zip 函数使用了 infix 修饰 , 可以使用如下方式进行调用 , 下面的调用是等效的 ;

    // 合并函数
    val nameAndAges = names.zip(ages)

    // 由于 zip 函数使用了 infix 修饰
    // 因此可以使用如下方式进行调用
    val nameAndAges2 = names zip ages

代码示例 :

fun main() {
    val names = listOf("Tom", "Jerry", "Jack")
    val ages = listOf(16, 17, 18)

    // 合并函数
    val nameAndAges = names.zip(ages)

    // 由于 zip 函数使用了 infix 修饰
    // 因此可以使用如下方式进行调用
    val nameAndAges2 = names zip ages

    println(nameAndAges)
    println(nameAndAges2)
}

执行结果 :

[(Tom, 16), (Jerry, 17), (Jack, 18)]
[(Tom, 16), (Jerry, 17), (Jack, 18)]

kotlin filter,Kotlin,kotlin,函数式编程,过滤函数,合并函数,谓词函数

2、folder 合并函数

folder 合并函数接收一个初始的累加器值 , 之后该值会根据匿名函数的执行结果进行更新 ;

folder 函数原型 :


/**
 * Accumulates value starting with [initial] value and applying [operation] from left to right
 * to current accumulator value and each element.
 * 从[初始值]开始累加值，从左到右应用[操作]到当前累加器值和每个元素。
 * 
 * Returns the specified [initial] value if the collection is empty.
 * 如果集合为空，则返回指定的[初始值]。
 * 
 * @param [operation] function that takes current accumulator value and an element, 
 * 		and calculates the next accumulator value. 
 * 		匿名函数，该函数获取当前累加器值和一个元素，并计算下一个累加器值。
 */
public inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

遍历集合中的元素 , 将集合中的元素进行平方后相加 ;

分析下面代码的执行过程 :

遍历集合元素 1 , 此时累加器值为 0 , 匿名函数返回结果 0 + 1 * 1 = 1 , 这个结果 1 会作为下一次遍历的累加器值 ;
遍历集合元素 2 , 此时累加器值为 1 , 匿名函数返回结果 1 + 2 * 2 = 5 , 这个结果 5 会作为下一次遍历的累加器值 ;
遍历集合元素 3 , 此时累加器值为 5 , 匿名函数返回结果 5 + 3 * 3 = 14 , 遍历完成 ;

代码示例 :

fun main() {
    val numbers = listOf(1, 2, 3).fold(0) {
        accumulator, number ->
        println("累加器值 : $accumulator, number : $number")
        accumulator + number * number
    }
    println(numbers)
}

执行结果 :

累加器值 : 0, number : 1
累加器值 : 1, number : 2
累加器值 : 5, number : 3
14

kotlin filter,Kotlin,kotlin,函数式编程,过滤函数,合并函数,谓词函数

五、函数式编程意义

函数式编程意义 :文章来源地址https://www.toymoban.com/news/detail-780070.html

代码量 : 函数式编程代码量远远小于传统的面向对象编程的代码量 ; 函数式编程一行调用链代码相当于 Java 几十行代码量 ;
- 代码量对比 : 函数式编程 < 面向对象编程 < 面向过程编程
- 可读性高 : 由于代码量减小 , 对应的中间变量和流程也大大的减少了 , 函数式编程的可读性远远高于面向对象编程 ;
健壮性 : 使用函数式编程 , 计算过程中使用的累加变量都是隐式定义的 , 运算结果自动赋值给累加变量 , 代码健壮性比较高 , 出错几率变小 ;
适配所有集合 : 函数式编程的变换 | 过滤 | 合并函数 , 都是为 Iterable<T> 类型定义的扩展函数 , 所有的集合都可以直接添加到函数式编程的调用链中 ;