函数式编程
- 高阶函数：以函数为参数或返回函数
- 函数式编程范式主要依赖于高阶函数返回的数据，这些高阶函数专用于处理各种集合
- 这些高阶函数可方便的联合多个同类函数构建链式操作以创建复杂的计算行为
函数类别
- 一个函数式应用通常由三大类构成：变换transform、过滤filter、合并combine
- 每类函数都针对集合数据类型设计，目标是产生一个最终结果
变换transform
- 变换函数会遍历集合内容
- 首先用一个以值参形式传入的变换器函数，变换每一个元素
- 然后返回包含已修改元素的集合给链上的其他变换器函数使用
- 最常用的两个变换函数式map和flatMap
map
val animals = listOf<String>("zebra", "giraffe", "elephant", "rat");
//变换器函数作用于集合里的各个元素，返回结果是包含已修改元素的集合，作为链上下一个函数的输入
val babies = animals.map { animal ->
"A baby $animal"
}.map { baby ->
"$baby ,with the cutest little tail ever!"
}
println(animals)
println(babies)
val animals_animals = listOf<String>("zebra", "giraffe", "elephant", "rat");
//map返回的集合中的元素个数和输入集合必须一样，不过，返回的新集合里面的元素可以是不同类型的
val animaslLength = animals_animals.map { it.length }
println(animaslLength)
flatMap
/**
* flatMap函数操作一个集合的集合，将其中多个集合中的元素合并后返回一个包含所有元素的单一集合
*/
fun main() {
val result = listOf(
listOf(1, 2, 3),
listOf(4, 5, 6)
).flatMap { it }
println(result)
}
过滤filter
- 过滤函数接受一个predicate函数，用它按给定条件检查接收者集合里的元素并给出true或false的判定
- 如果predicate函数返回true,受检元素添加到过滤函数返回新集合里
- 如果返回false,受检元素被移出新集合里
/**
* 过滤函数接受一个predicate函数，用它按给定条件检查接受者集合里的元素并给出true或false的判定
* 如果predicate函数返回true,受检元素会添加到过滤函数返回的新集合里
* 如果predicate函数返回false,受检元素会移出到过滤函数返回的新集合里
*/
fun main() {
val result = listOf<String>("Jack", "Jimmy", "Rose", "Tom")
.filter { it.contains("J") }
println(result)
}
/**
* filter过滤函数接受一个predicate函数,在flatMap遍历它的输入集合
*/
fun main() {
val items = listOf(
listOf("red apple", "green apple", "blue apple"),
listOf("red fish", "blue fish"),
listOf("yellow banan", "teal banana")
);
val redItems = items.flatMap {
//在flatMap遍历它的输入集合中的所有元素时
//filter函数会让predicate函数按过滤条件，将符合条件的元素都放入它返回的新集合里
it.filter { it.contains("red") }
}
println(redItems)
println(2 until 10);//(2..9)
//找素数
val numbers = listOf<Int>(7, 4, 8, 4, 3, 22, 18, 11);
val peimes = numbers.filter { num ->
//先过滤出一个集合，集合中所有元素都不等于0,那么就是素数
(2 until num).map { num % it }
.none { it == 0 }
}
println(peimes)
}
合并combine
- 合并函数能将不同的集合合并成一个新集合
- 不同于接受者是包含集合的集合的flatMap函数
zip
- zip合并函数来合并两个集合，返回一个包含键值对的新集合
val employees = listOf("Jack", "Jason", "Tommy");
val shirtSize = listOf("large", "x-large", "medium")
//zip合并函数来合并两个集合，返回一个包含键值对的新集合
val employeeshirtSize = employees.zip(shirtSize).toMap();
println(employeeshirtSize["Jack"])
fold
- 这个合并函数接受一个初始累加器值，随后会根据匿名函数的结果更新
//fold合并函数接受一个初始累加器值，随后会根据匿名函数的结果更新
//accumulator参数是初始累加器值,后面参数是匿名函数
val foldedValue = listOf(1, 2, 3, 4).fold(0) { accumulator, number ->
accumulator + (number * 3)
}
println("Final value: $foldedValue")
序列
-
Kotlin有个内置惰性集合类型叫序列Sequence；
-
惰性集合，类似于惰性初始化，包含大量元素是，集合元素是按需产生的；文章来源：https://www.toymoban.com/news/detail-525034.html
-
在使用一个序列时，序列里的值可能有无限多，因为某个数据源可能产生无限多个元素；文章来源地址https://www.toymoban.com/news/detail-525034.html
generateSequence
private fun Int.isPrime(): Boolean {
(2 until this).map {
if (this % it == 0) return false;
}
return true;
}
fun main() {
val list = (1..5000).toList().filter {
it.isPrime()
}.take(1000);
println(list.size)
/**
* 第一个参数，接受一个初始种子值作为序列的起步值
*
* 第二个参数，匿名函数是指定的迭代器函数，决定下一个要产生的值
*/
val sequenceList = generateSequence(2) { value ->
value + 1
}.filter { it.isPrime() }.take(1000);
println(sequenceList.toList().size)
}
到了这里，关于学习Kotlin~函数式编程的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
