当前位置: 首页>编程语言>正文

kotlin 遍历索引 kotlin 列表

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

这里对 Kotlin 中四种 item collection 的方式进行整理和介绍:List, Set, MapSequences



文章目录

  • 一起来学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 个素数。 还有其他用于初始化序列的语法,我们可以在此处查看。



https://www.xamrdz.com/lan/5cf1957303.html

相关文章: