Kotlin - 常见高阶函数
# forEach
高阶函数 forEach
是可迭代对象的扩展方法,接收函数类型是 (T) -> Unit
的参数 action,forEach
会将 action 这个函数作用于可迭代对象中的每个元素,这是源码:
/**
* Performs the given [action] on each element.
*/
@kotlin.internal.HidesMembers
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
for (element in this) action(element)
}
根据 forEach 的入参要求,我们给其传递一个 lambda 表达式或是函数引用:
fun main(args: Array<String>) {
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
// list.forEach { it -> println(it) } // it可以省略
list.forEach { println(it) }
list.forEach(::println)
list.forEachIndexed { index, i -> println("index=$index, value=$i") }
}
forEachIndexed
相比forEach
只是多了索引 index。
# map
高阶函数 map
也是可迭代对象的扩展方法,根据 map
的源码与注释,我们知道 map 接收一个类型是 (T) -> R
的参数 transform,map
会将 transform 作用于可迭代对象中的每个元素,并最终返回一个新的集合 List:
/**
* Returns a list containing the results of applying the given [transform] function
* to each element in the original collection.
*
* @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)
}
借助 map 的功能,我们可以将一个数组 “映射” 成另一个数组,这在日常开发很有用:
fun main(args: Array<String>) {
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
// 将int数组中的元素经过某种运算形成一个新的int数组
val newList = list.map { it * 2 + 3 }
newList.forEach(::println)
// 将int转成double
val newList2 = list.map(Int::toDouble) // (Int) -> Double
newList2.forEach(::println)
}
注意:toDouble()是 Int 类中的一个方法,在函数引用部分已经讲过,当使用
类名::方法名
这种方式引用一个成员方法时,会自动在函数类型的参数列表第 1 位多出一个接收者Receiver
,用于接收类实例对象 ,刚好 toDouble()没有参数列表,因此Int::toDouble
对应的函数类型是(Int) -> Double
,符合高阶函数 map 的参数要求。
# flatMap
高阶函数 flatMap
比 map
高一个维度,可以将可迭代对象中的每个可迭代对象进行处理,最终返回一个 扁平化
的可迭代对象,注意参数 transform 的函数类型是 (T) -> Iterable<R>
:
/**
* Returns a single list of all elements yielded from results of [transform] function being invoked on each element of original collection.
*
* @sample samples.collections.Collections.Transformations.flatMap
*/
public inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R> {
return flatMapTo(ArrayList<R>(), transform)
}
什么是 扁平化
,直观的说,就是胖变瘦,多维变一维:
fun main(args: Array<String>) {
val list = listOf(
8..10,
1..3,
98..100
)
val flatList = list.flatMap { it } // it->it,这里同时也是 (Iterable) -> Iterable
flatList.forEach(::println) // 这时的 flatList 就相当于 [8,9,10,1,2,3,98,99,100]
}
flatMap
除了 扁平化
这个特性外,也拥有 map 的特性,可以将可迭代对象中的元素进行转换处理:
fun main(args: Array<String>) {
val list = listOf(
8..10,
1..3,
98..100
)
val flatList2 = list.flatMap { intRange ->
intRange.map { intElement -> "No. $intElement " } // 把Int转成String
}
flatList2.forEach(::print) // No. 8 No. 9 No. 10 No. 1 No. 2 No. 3 No. 98 No. 99 No. 100
}
# filter
高阶函数 filter
可以将可迭代对象进行过滤,只有满足 predicate 过滤条件的元素(即 return true)才会被 "留下":
/**
* Returns a list containing only elements matching the given [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
过滤出数组中的奇数:
fun main(args: Array<String>) {
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val newList = list.filter { it % 2 == 1 }
newList.forEachIndexed { index, i -> print(if (index > 0) " $i" else i) } // 1 3 5 7
}
# takeWhile
高阶函数 takeWhile
会在遇到第一个不符合条件的元素时就结束取数据,留下前面的作为新的集合返回:
/**
* Returns a list containing first elements satisfying the given [predicate].
*
* @sample samples.collections.Collections.Transformations.take
*/
public inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T> {
val list = ArrayList<T>()
for (item in this) {
if (!predicate(item))
break
list.add(item)
}
return list
}
我们可以使用 takeWhile 筛选出前面满足条件的元素:
fun main(args: Array<String>) {
val list = listOf(1, 1, 2, 3, 5, 8, 13, 21)
var newList = list.takeWhile { it % 2 == 1 } // 筛选出前面的奇数
newList.forEachIndexed { index, i -> print(if (index > 0) " $i" else i) } // 1 1
newList = list.takeWhile { it < 5 } // 筛选出前面小于5的数
newList.forEachIndexed { index, i -> print(if (index > 0) " $i" else i) } // 1 1 2 3
}
# reduce
高阶函数 reduce
会从第一个元素开始累加,并从左到右将 operation 函数应用于当前累加值和每个元素:
/**
* Accumulates value starting with the first element and applying [operation] from left to right to current accumulator value and each element.
*
* @sample samples.collections.Collections.Aggregates.reduce
*/
public inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S {
val iterator = this.iterator()
if (!iterator.hasNext()) throw UnsupportedOperationException("Empty collection can't be reduced.")
var accumulator: S = iterator.next()
while (iterator.hasNext()) {
accumulator = operation(accumulator, iterator.next())
}
return accumulator
}
我们可以用 reduce
来处理一些累加的操作,如计算 1 到 8 之间所有的数进行求和:
fun main(args: Array<String>) {
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val result = list.reduce { acc, i -> acc + i }
println(result) // 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 = 36
}
# fold
高阶函数 fold
跟 reduce
差不多,只是 fold
多了一个初始值,后续处理与 reduce
一样:
/**
* Accumulates value starting with [initial] value and applying [operation] from left to right to current accumulator value and each element.
*/
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
}
我们可以 fold 来计算在 100 的基础上,再累加 1 到 8 的和:
fun main(args: Array<String>) {
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8)
val result = list.fold(100, { acc, i -> acc + i })
println(result) // 100 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 = 37
}
- 01
- Flutter - 子部件任意位置观察滚动数据11-24
- 02
- Flutter - 危!3.24版本苹果审核被拒!11-13
- 03
- Flutter - 轻松搞定炫酷视差(Parallax)效果09-21