一起来学Kotlin：概念：13. Kotlin List, Set, Map, Sequence
这里对 Kotlin 中四种 item collection 的方式进行整理和介绍：List, Set, Map，Sequences。
文章目录
- 一起来学Kotlin：概念：13. Kotlin List, Set, Map, Sequence
- 1 List 列表
- 2 Set 集合
- 3 Map 映射
- 4 Sequences 序列
1 List 列表
A list is an ordered collection of items.
在 Kotlin 中，列表可以是可变的（MutableList）或只读的（List）。对于列表创建，对只读列表使用标准库函数 listOf()，对可变列表使用可变 mutableListOf()。若要防止进行不必要的修改，请将可变列表转换为 List，从而获取可变列表的只读视图。
所以，一句话概括，如果我们想要修改这个列表，那么我们就需要定义其为 MutableList。反之，如果我们只是需要使用这个列表，那么定义其为 List 即可。
下面这个例子可以说明问题：
val systemUsers: MutableList<Int> = mutableListOf(1, 2, 3)
// 创建一个 MutableList，是可变的，需要注意的是，我们定义 systemUsers 的时候使用的是 val，而不是 var
val sudoers: List<Int> = systemUsers
// 创建一个 List，这个 List 是只读的
fun addSystemUser(newUser: Int) {
systemUsers.add(newUser)
}
// 对于可变列表来说，我们可以添加，删除，其中的元素
fun getSysSudoers(): List<Int> {
return sudoers
}
fun main() {
addSystemUser(4)
// 更新可变列表。需要注意，所有相关的只读List也会更新，因为它们指向同一对象。
println("Tot sudoers: ${getSysSudoers().size}")
// 打印 Tot sudoers: 4。所以，这里就证实了上面的解释
getSysSudoers().forEach {
i -> println("Some useful info on user $i")
}
// 打印 Some useful info on user 1
// 打印 Some useful info on user 2
// 打印 Some useful info on user 3
// 打印 Some useful info on user 4
// getSysSudoers().add(5) <- Error!
// 尝试写入只读视图会导致编译错误。
}2 Set 集合
A set is a generic unordered collection of elements which allows no duplicates.
对于创建集合，有 只读集合setOf() 和 可变集合mutableSetOf()。这个改变和区别基本和 List 是一致的。
下面这个例子可以说明问题：
val openIssues: MutableSet<String> = mutableSetOf("uniqueDescr1", "uniqueDescr2", "uniqueDescr3")
// 定义一个可变集合MutableSet，这个集合里面每一个元素都是 String。
// 添加一个元素，这里返回BOOL，反应十分添加成功
fun addIssue(uniqueDesc: String): Boolean {
return openIssues.add(uniqueDesc)
}
// 如果已经添加，则返回 "registered correctly."
fun getStatusLog(isAdded: Boolean): String {
return if (isAdded) "registered correctly." else "marked as duplicate and rejected."
}
fun main() {
val aNewIssue: String = "uniqueDescr4"
val anIssueAlreadyIn: String = "uniqueDescr2"
val listEx = listOf(1, 2, 3, 3, 3)
val setEx = setOf(1, 2, 3, 3, 3)
println("$listEx")
// 打印：[1, 2, 3, 3, 3]，所以说，List是可以重复的，而且有序的，比如，listEx[0]是允许的。
println("$setEx")
// 打印：[1, 2, 3]，所以说，Set是不可以重复的，
// println("${setEx[0]}")
// 会报错
println("${listEx[0]}")
// 打印 1
println("${setEx.elementAt(0)}")
// 打印 1
val i1 = setEx.indexOf(3)
println("The first index of setEx is $i1")
// 打印：The first index of setEx is 2
val i2 = setEx.lastIndexOf(3)
println("The last index of setEx is $i2")
// 打印：The last index of setEx is 2。再次证明了集合内的元素是不重复的
println("Issue $aNewIssue ${getStatusLog(addIssue(aNewIssue))}")
// 打印：Issue uniqueDescr4 registered correctly.
println("Issue $anIssueAlreadyIn ${getStatusLog(addIssue(anIssueAlreadyIn))}")
// 打印：Issue uniqueDescr2 marked as duplicate and rejected.
}3 Map 映射
A map is a collection of key/value pairs, where each key is unique and is used to retrieve the corresponding value.
对于创建映射，有函数 mapOf() 和 mutableMapOf()。这个改变和区别基本和 List 是一致的。
下面这个例子可以说明问题：
const val POINTS_X_PASS: Int = 15
val EZPassAccounts: MutableMap<Int, Int> = mutableMapOf(1 to 100, 2 to 100, 3 to 100)
// 创建一个 MutableMap，这里我们使用 to 将 key 和 value 对应，比如 1 对应 100，2 对应 100，等等
val EZPassReport: Map<Int, Int> = EZPassAccounts
// 将这个 MutableMap cast 到 Map，这个和 list 类似
fun updatePointsCredit(accountId: Int) {
// 这里的 Map 和 Python 的 Dict 相类似，检查是否这个 Map 的 Key 存在
if (EZPassAccounts.containsKey(accountId)) {
println("Updating $accountId...")
EZPassAccounts[accountId] = EZPassAccounts.getValue(accountId) + POINTS_X_PASS
// 读取相应的值，并用常量值递增它。
} else {
println("Error: Trying to update a non-existing account (id: $accountId)")
}
}
// 虽然不是一定要这么做，但是这个例子中，但凡是需要改变的操作都在 MutableMap 中进行，但凡是那些读取的操作都在 Map 中进行
fun accountsReport() {
println("EZ-Pass report:")
EZPassReport.forEach {
k, v -> println("ID $k: credit $v")
}
}
fun main() {
accountsReport()
// 打印
// EZ-Pass report:
// ID 1: credit 100
// ID 2: credit 100
// ID 3: credit 100
updatePointsCredit(1)
// 打印：Updating 1...
updatePointsCredit(1)
updatePointsCredit(5)
// 打印：Updating 1...
accountsReport()
// 打印
// EZ-Pass report:
// ID 1: credit 130
// ID 2: credit 100
// ID 3: credit 100
}4 Sequences 序列
List、Set 和 Map 等集合类型也称为 eager collections ，因为一旦它们被实例化，它们包含的所有值都是现成的并且可以访问。 尽管也是集合并共享相同的功能，但序列仅在被请求时才计算单个值。 换句话说，它们是按需生成每个项目的 lazy collections。比如下面这个例子：
val n = 10
val testSequence = generateSequence(0){ it + 1 }.filter { it.isPrime() }
println(testSequence) // nothing computed yet, prints memory location of sequence
println("sequence: ${testSequence.take(n).toList()}") // prints first 10 prime numbers
val testList = (0..n).toList().filter { it.isPrime() } // values already computed
println("list: $testList") //prints prime numbers in first 10 positive numbers
//output:
//kotlin.sequences.FilteringSequence@7cc355be
//sequence: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
//list: [2, 3, 5, 7]请注意，在我们使用第 5 行中的 take 函数实际请求它们之前，系统不会计算序列的值，而列表值是立即计算的。这有一些重要的含义，我们将在下面更详细地研究这些含义。
另一个值得注意的点是，序列输出 10 个值，而列表仅输出 4 个，即使它们都输入了相同的参数 n。或者说，上面的序列生成素数，我们要求它的前 10 个值； 上面的列表过滤了素数，我们给它输入了前 10 个正数，这个范围内有 4 个素数。
Infinite Sequences
上面的例子展示了序列的强大之处：它们可以产生无限满足条件的元素。也就是说，我们可以将 n 更改为任何值，并且序列总是会产生前 n 个素数。这种行为对于列表来说是不可能的，因为它们没有从以前的值（如序列）构建的构造函数。
事实上，这解释了语法 generateSequence(0){it + 1}。 传递给函数的参数是初始 seed 值（在本例中为 0），lambda 指示每次需要新项目时如何处理它（将其加一）。 在上面的例子中，只有满足过滤条件的序列才会返回一个值，确保我们总是得到 n 个素数。 还有其他用于初始化序列的语法，我们可以在此处查看。