fun main() {
    var citys = listOf("北京", "上海", "广州", "深圳")
    var chinaCitys = citys
        .map { citys -> "中国-$citys" }
        .map { china -> "$china，一线城市！" }
    //原始集合
    println(citys)
    //修改原始集合元素
    println(chinaCitys)
}

可以看到，原始集合没有被修改，map变换函数和你定义的变换器函数做完事情后，返回的是一个新集合，这样，变量就不用变来变去了。

事实上，函数式编程范式支持的设计理念就是不可变数据的副本在链上的函数间传递。

2.1.2 flatMap

flatMap函数操作一个集合的集合，将其中多个集合中的元素合并后返回一个包含所有元素的单一集合。

    //一个集合的集合:List<List<String>>
    var cityslist = listOf(listOf("北京", "上海", "广州", "深圳"), listOf("合肥","杭州","成都"))
    //多个集合中的元素合并，返回一个新集合flatCity
    var flatCity = cityslist.flatMap { it }

    //原始集合
    println(cityslist)//[[北京, 上海, 广州, 深圳], [合肥, 杭州, 成都]]
    //合并后集合元素
    println(flatCity)//[北京, 上海, 广州, 深圳, 合肥, 杭州, 成都]

2.2 过滤filter

过滤是函数式编程的第二大类函数，过滤函数接受一个predicate函数，用它按给定条件检查接收者集合里的元素并给出true或false的判定。

如果predicate函数返回true，受检元素就会添加到过滤函数返回的新集合里。
如果predicate函数返回false，那么受检元素就被移出新集合。

可以理解为按条件筛选元素。

fun main() {
    var number = listOf(1,3,5,7,12,19,21)
    //过滤元素大于15的元素，并添加到新集合
    var newNumber = number.filter { it>15 }
    //原始数据
    println(number)//[1, 3, 5, 7, 12, 19, 21]
    //过滤后
    println(newNumber)//[19, 21]
}

filter+flatMap

对一个集合的集合先合并再过滤。

    //flatMap+filter
    var numberList = listOf(
        listOf(1, 2, 3, 4, 5),
        listOf(6, 7, 8, 9, 10), listOf(11, 12, 13, 14, 15)
    )
    //先合并，后过滤
    var newNumberList = numberList.flatMap { it.filter { it % 2 == 0 } }
    println(numberList)//[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]
    println(newNumberList)//[2, 4, 6, 8, 10, 12, 14]

2.3 合并combine

合并是函数式编程的第三大类函数，合并函数能将不同的集合合并成一个新集合，这和接收者是包含集合的集合的flatMap函数不同。

2.3.1 zip

zip合并函数来合并两个集合，返回一个包含键值对的新集合。

fun main() {
    val name = listOf("变换","过滤","合并")
    val age = listOf(7, 25, 36)
    val list = name.zip(age)
    println(list)//[(变换, 7), (过滤, 25), (合并, 36)]
    val map = list.toMap()
    println(map)//{变换=7, 过滤=25, 合并=36}
    println(map["过滤"])//25
}

2.3.2 fold

fold合并函数接受一个初始累加器值，随后会根据匿名函数的结果更新。

fun main() {
    //初始值为10，将每个元素乘以2相加
    var total = listOf(4, 8, 12).fold(10) { total, number ->
        println("Total：$total")
        total + (number * 2)
    }
    println(total)
}

三、序列

及早集合（eager collection)：List、Set、Map集合的任何一个实例在创建后，它要包含的元素都会被加入并允许你访问。
惰性集合〈lazy collection）：类似于类的惰性初始化，惰性集合类型的性能表现优异，尤其是用于包含大量元素的集合时，因为集合元素是按需产生的。

Kotlin有个内置惰性集合类型叫序列(Sequence)，序列不会索引排序它的内容，也不记录元素数目，事实上，在使用一个序列时，序列里的值可能有无限多，因为某个数据源能产生无限多个元素。

generateSequence

generateSequence函数接受一个初始种子值作为序列的起步值，在用generateSequence定义的序列上调用一个函数时，generateSequence函数会调用你指定的迭代器函数，决定下一个要产生的值。

fun main() {
    //在1-3000的范围内产生1000个能同时整除2和整除7的数
    val list = (1..3000).toList().filter { it % 2 == 0 && it % 7 == 0 }.take(1000)
    println(list.size)//214
    //[14, 28, 42, 56, 70, 84, 98, ...2954, 2968, 2982, 2996]
    println(list)

    //使用序列,取满足条件的1000个为止
    val slist = generateSequence(1,
        { num ->
            num + 1
        })
        .filter { it % 2 == 0 && it % 7 == 0 }
        .take(1000)
        .toList()

    println(slist.size)//1000
    //[14, 28, 42, 56, 70, 84, 98, ...13958, 13972, 13986, 14000]
    println(slist)
}

【Kotlin 初学者】函数式编程

一、函数式编程概念

1.1 面向函数编程（FOP）

1.2 高阶函数

1.3 为什么使用函数式编程

二、函数式编程类别

2.1 变换transform

2.1.1 map