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

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

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

    println(hasJCharacter)
}

[Jerry, Jack]

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]

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]

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

/**
 * 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  Iterable.zip(other: Iterable): List> {
    return zip(other) { t1, t2 -> t1 to t2 }
}

// 合并函数
    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)]

/**
 * 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  Iterable.fold(initial: R, operation: (acc: R, T) -> R): R {
    var accumulator = initial
    for (element in this) accumulator = operation(accumulator, element)
    return accumulator
}

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