Kotlin 13. Kotlin List, Set, Map, Sequence

一起来学Kotlin：概念：13. Kotlin List, Set, Map, Sequence

这里对 Kotlin 中四种 item collection 的方式进行整理和介绍：List, Set, Map，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 个素数。 还有其他用于初始化序列的语法，我们可以在此处查看。