这里对 Kotlin 中四种 item collection 的方式进行整理和介绍:List
, Set
, Map
,Sequences
。
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!
// 尝试写入只读视图会导致编译错误。
}
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.
}
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
}
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 个素数。 还有其他用于初始化序列的语法,我们可以在此处查看。