高阶函数

kotlin-stdlib-common 包下

高阶函数：接收另一个函数（函数类型）作为参数，或返回值的类型是另一个函数。
2.1 map:将List中每个元素转换成新的元素,并添加到一个新的List中,最后将新List返回

arrayOf(1, 2, 3).map { i: Int -> i * 10 }.forEach(::println)
/**
 * 打印输出
 * 10
 * 20
 * 30
 */
2.2 flatMap

flatMap:将数组中全部元素按顺序组成一个list
//注意:lambda表达式中的参数类型可以不写.如:List<String>和IntRange
listOf(listOf("a", "b"), listOf("c", "d")).flatMap { i: List<String> -> i.asIterable() }.forEach(::println)
println("----------")
arrayOf(1..3, 1..5).flatMap { i: IntRange -> i.asIterable() }.forEach(::println)
/**
 * 打印输出
 * a
 * b
 * c
 * d
 * ----------
 * 1
 * 2
 * 3
 * 1
 * 2
 * 3
 * 4
 * 5
 */
2.3 fold

fold:将集合中的元素依次冒泡组合,最终得到一个结果
 
val foldResult1 = arrayOf(1, 2, 3).fold(10, { a, b -> a + b })//计算过程为10+1+2+3,等于16
val foldResult2 = arrayOf(1, 2, 3).fold(10, { a, b -> a * b })//计算过程为10*1*2*3,等于60
println(foldResult1)
println(foldResult2)
/**
 * 打印输出
 * 16
 * 60
 */
2.4 reduce 计算

val reduceResult1 = arrayOf(1, 2, 3, 4).reduce { acc, i -> acc + i }//计算过程为1+2+3+4,等于10
val reduceResult2 = arrayOf(1, 2, 3, 4).reduce { acc, i -> acc * i }//计算过程为1*2*3*4,等于24
val reduceResult3 = arrayOf("a", "b", "c", "d").reduce { acc, i -> "$acc,$i" }
println(reduceResult1)
println(reduceResult2)
println(reduceResult3)
/**
 * 打印输出
 * 10
 * 24
 * a,b,c,d
 */

2.5 joinToString

joinToString:为集合元素添加分隔符,组成一个新的字符串并返回
 */
val joinToStringResult1 = arrayOf("a", "b", "c", "d").joinToString { i -> i }
val joinToStringResult2 = arrayOf("a", "b", "c", "d").joinToString(separator = "#", prefix = "[前缀]", postfix = "[后缀]", limit = 3, truncated = "[省略号]") { i -> i }
println(joinToStringResult1)
println(joinToStringResult2)
/**
 * 打印输出
 * a, b, c, d
 * [前缀]a#b#c#[省略号][后缀]
 */
2.6 filter

filter:将中的元素遍历,把符合要求的元素添加到新的list中,并将新list返回
 */
//根据元素值来过滤
arrayOf(1, 2, 3, 0, 4).filter { i -> i >= 2 }.forEach(::println)
println("----------")
//根据索引来过滤
arrayOf(1, 2, 3, 0, 4).filterIndexed { index, i -> index >= 2 }.forEach(::println)
/**
 * 打印输出
 * 2
 * 3
 * 4
 * ----------
 * 3
 * 0
 * 4
 */
2.7 takeWhile

takeWhile:遍历list中的元素,将符合要求的元素添加到新集合中
 * 注意:一旦遇到不符合要求的,直接终止
 */
//注意:返回的集合中只有4和3,没有5,因为遇到2时,不符合要求,程序直接终止
arrayOf(4, 3, 2, 5).takeWhile { i -> i > 2 }.forEach(::println)
/**
 * 打印输出
 * 4
 * 3
 */‘
2.8 takeIf()函数

从函数的名字我们可以看出，这是一个关于条件判断的函数,我们在看其源码实现：

public inline fun <T> T.takeIf(predicate: (T) -> Boolean): T? {
    contract {
        callsInPlace(predicate, InvocationKind.EXACTLY_ONCE)
    }
    return if (predicate(this)) this else null
}
从源码中我们可以得出这个函数的作用是：

传入一个你希望的一个条件，如果对象符合你的条件则返回自身，反之，则返回null。

例： 判断一个字符串是否由某一个字符起始，若条件成立则返回自身，反之，则返回null

val str = "kotlin"

val result = str.takeIf {
    it.startsWith("ko") 
}

println("result = $result")
输出结果为：

result = kotlin