什么是函数式编程
函数式编程是于面向对象编程范式相齐名的一种编程方式，主要依赖于高阶函数返回的数据，这些高阶函数专用于处理各种集合，可方便的联合多个同类函数构建链式操作以创建复杂的计算行为。在Kotlin中支持多种编程范式，
有以下函数类别：
变换transform、过滤filter、合并combine。
变换
变换是函数式编程的第一大类函数，变换函数会遍历集合内容，用一个以值参的形式传入的变换器函数，变换每一个元素，然后返回已包含修改数据的集合并可传给链上的其他函数。
Kotlin中常见的变换函数中有map和flatMap。
map，会遍历接收者集合，让变换器函数作用于集合中的各个元素，返回结果是已修改元素的集合，可以作为链上下一个函数的输入。
flatMap，操作一个集合的集合，将多个集合的元素合并并返回一个包含所有元素的单一集合。
看个变换函数map的实例：
//1.变换函数map
private fun mapTest() {
val list = listOf<Int>(2, 5, 8, 10, 22)
//变换后的新列表
val newList = list.map {
it * 2 + 3
}
println("mapTest newList:$newList")
}
输出：mapTest newList:[7, 13, 19, 23, 47]
在来看个flatMap的实例：
//2.变换函数flatMap
private fun flatMapTest() {
val list1 = listOf(1,2,3,4)
val list2 = listOf(7,8,9)
val newList = listOf(list1,list2).flatMap {
it
}
println("flatMapTest newList:$newList")
}
输出：flatMapTest newList:[1, 2, 3, 4, 7, 8, 9]
过滤
过滤是Kotlin中函数式编程的第二大类函数，过滤函数接收一个predicate函数，该函数提供了一个查询条件用于查询集合中的元素并给出true或false的结果。如果predicate函数返回true，则将元素添加到新的集合中，如果返回false，则受检元素则移出新集合。
常用的过滤函数为：filter。
以下为例子：
val list = listOf("I","like","kotlin")
val filterList = list.filter { it.contains("k") }
println("filterList : $filterList")
输出：filterList : [like, kotlin]
合并
合并是Kotlin中函数式编程的第三大类函数，合并函数能将不同的集合合并成一个新的集合。与接收者flatMap函数有不同。
Kotlin中常用的合并函数为：zip和fold。
zip，合并函数来合并两个集合，并返回一个包含键值对的新集合。
fold，函数接收一个初始累加器值，随后会根据匿名函数的结果更新。
/**
* 合并函数 - zip，合并函数来合并两个集合，并返回一个包含键值对的新集合
*/
private fun zipTest(){
val list = listOf("a","b","c")
val listValue = listOf(28,30,33)
//合并后转成map
val zipMap = list.zip(listValue).toMap()
println("ZipTest : $zipMap")
println("zipList[\"a\"]=${zipMap["a"]}")
}
输出：
ZipTest : {a=28, b=30, c=33}
zipList[“a”]=28
fold示例：
/**
* 合并函数 - fold,函数接收一个初始累加器值，随后会根据匿名函数的结果更新
*/
private fun foldTest(){
val list = listOf(1,2,3,4)
val foldValues = list.fold(0){acc, number ->
println("初始累计值：$acc")
acc + (number * 3)
}
println("foldValues : $foldValues")
}
输出：
初始累计值：0
初始累计值：3
初始累计值：9
初始累计值：18
foldValues : 30
序列
Kotlin内置的惰性集合叫序列，序列不会索引排序它的内容，也不记录元素数目，事实上，在使用一个序列时，序列里的值可能有无限多，因为某个数据源能产生无限多个元素。
使用的序列为：generateSequence，该函数接收一个初始种子值作为序列的起步值，在用generateSeuence定义的序列调用函数时，generateSequence会调用你指定的迭代器函数来决定下一个要产生的值。
下面以产生100个素数为例子：
fun main(){
val value = generateSequence(2){
it+1
}.filter { it.isPrime() }.take(100)
println("${value.count()}")
}
fun Int.isPrime():Boolean{
val ret = (2 until this).map {
this % it
}.none { it == 0 }
return ret
}
输出：100