Kotlin学习——kt里的集合List，Set，Map & List集合的各种方法之Int篇

Kotlin 是一门现代但已成熟的编程语言，旨在让开发人员更幸福快乐。 它简洁、安全、可与 Java 及其他语言互操作，并提供了多种方式在多个平台间复用代码，以实现高效编程。

https://play.kotlinlang.org/byExample/01_introduction/02_Functions

其他关于kt的博客文章如下：

• Kotlin学习------hello kotlin & 函数function & 变量 & 类 + 泛型 + 继承
• Kotlin学习------流程控制，when，循环，range工具 & kt里的equals & if实现类似三元表达式的效果
• Kotlin学习------kt中的类，数据类 & 枚举类 & 密封类，以及对象
• Kotlin学习------kt里面的函数，高阶函数 & 函数式编程 & 扩展函数和属性

目录

• 引出
• kotlin里的集合
• • List
  • Set
  • Map
• List集合的各种方法
• • filter过滤
  • [map 所有元素](#map 所有元素)
  • any，all，none
  • first，last首尾
  • count统计
  • partition隔断
  • [minOrNul，maxOrNull 最小和最大](#minOrNul，maxOrNull 最小和最大)
  • sort排序
  • [getOrElse 安全访问](#getOrElse 安全访问)
  • 所有代码
• 总结

引出

---

1.kt里的集合List，Set，Map，可变集合和不可变集合；

2.list集合支持的各种方法，类似于Java里面的流stream；

kotlin里的集合

List

列表是项目的有序集合。在Kotlin中，列表可以是可变的（MutableList），也可以是只读的（List）。对于列表创建，对于只读列表使用标准库函数listOf（），对于可变列表使用mutableListOf（）。为了防止不必要的修改，可以通过将可变列表强制转换为List来获得可变列表的只读视图。

package com.tianju.collKt

// 创建一个可变列表
val systemUsers: MutableList<Int> = mutableListOf(1, 2, 3)
// 不可变列表，不能改变元素，相当于只读列表
val sudoers: List<Int> = systemUsers

/**
 * 可变列表可以增加元素
 */
fun addSystemUser(newUser: Int) {
    systemUsers.add(newUser)
}

/**
 * 返回只读列表
 */
fun getSysSudoers(): List<Int> {
    return sudoers
}

fun main() {
    addSystemUser(4)
    println("Tot sudoers: ${getSysSudoers().size}")
    getSysSudoers().forEach {
            i -> println("Some useful info on user $i")
    }
}

Set

set是不支持重复项的无序集合

package com.tianju.collKt

val openIssues: MutableSet<String> = mutableSetOf("uniqueDescr1", "uniqueDescr2", "uniqueDescr3")

/**
 * 给set 里面添加元素
 */
fun addIssue(uniqueDesc: String): Boolean {
    return openIssues.add(uniqueDesc)
}

/**
 * 返回日志
 */
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"

    println("Issue $aNewIssue ${getStatusLog(addIssue(aNewIssue))}")
    println("Issue $anIssueAlreadyIn ${getStatusLog(addIssue(anIssueAlreadyIn))}")
}

Map

映射是键/值对的集合，其中每个键都是唯一的，用于检索相应的值。对于创建映射，有函数mapOf（）和mutableMapOf（）。使用to infix函数可以减少初始化的噪声。可变映射的只读视图可以通过将其强制转换为map来获得。

package com.tianju.collKt

const val POINTS_X_PASS: Int = 15
val EZPassAccounts: MutableMap<Int, Int> = mutableMapOf(1 to 100, 2 to 100, 3 to 100)
// 创建一个只读map
val EZPassReport: Map<Int, Int> = EZPassAccounts

fun updatePointsCredit(accountId: Int) {
    // 检查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)")
    }
}

// 打印key：value
fun accountsReport() {
    println("EZ-Pass report:")
    EZPassReport.forEach {
            k, v -> println("ID $k: credit $v")
    }
}

fun main() {
    accountsReport()
    updatePointsCredit(1)
    updatePointsCredit(1)
    updatePointsCredit(5)
    accountsReport()
}

List集合的各种方法

filter过滤

val nums = listOf(1,3,5,6,3,-4,-3)

// 过滤
val postNums = nums.filter { x -> x>0 }
val negNums = nums.filter { it < 0 }

map 所有元素

// map函数，作用于所有元素
val doubled = nums.map { x->x*2 }
val tripled = nums.map { it*3 }

any，all，none

返回值为Boolean

// any, all, none
// 返回值为Boolean 布尔
val anyPost = nums.any { it>0 }
val allEven = nums.all { it%2 ==0 }
val allLess6 = nums.none { it>7 }

first，last首尾

// 第一个元素，最后一个元素
val firstNum = nums.first()
val lastNum = nums.last()
// 可以传一个表达式
val firstEven = nums.first { it%2==0 }

count统计

// count
val totalNums = nums.count()
val evenCount = nums.count {it%2==0}

partition隔断

按照条件分割成两个阵营

// partition 隔断
// ([6, -4], [1, 3, 5, 3, -3])
val evenOdd = nums.partition { it%2 ==0 }

println(evenOdd.first)

minOrNul，maxOrNull 最小和最大

minOrNull和maxOrNull函数返回集合中最小和最大的元素。如果集合为空，则返回null。

// minOrNull和maxOrNull函数返回集合中最小和最大的元素。如果集合为空，则返回null。
val numbers = listOf(1, 2, 3)
val empty = emptyList<Int>()
val only = listOf(3)

sort排序

// 排序sorted
val shuffled = listOf(5, 4, 2, 1, 3, -10)
val natural = shuffled.sorted()
// 取负数后排序
val inverted = shuffled.sortedBy { -it }
// 顺序
val descending = shuffled.sortedDescending()
val descendingBy = shuffled.sortedByDescending { kotlin.math.abs(it) }

getOrElse 安全访问

getOrElse提供对集合元素的安全访问。它采用一个索引和一个函数，该函数在索引越界时提供默认值。

// getOrElse
val get1 = nums.getOrElse(1){56}
val get100 = nums.getOrElse(100){200}

所有代码

package com.tianju.collKt


val nums = listOf(1,3,5,6,3,-4,-3)

// 过滤
val postNums = nums.filter { x -> x>0 }
val negNums = nums.filter { it < 0 }

// map函数，作用于所有元素
val doubled = nums.map { x->x*2 }
val tripled = nums.map { it*3 }

// any, all, none
// 返回值为Boolean 布尔
val anyPost = nums.any { it>0 }
val allEven = nums.all { it%2 ==0 }
val allLess6 = nums.none { it>7 }

// 第一个元素，最后一个元素
val firstNum = nums.first()
val lastNum = nums.last()
// 可以传一个表达式
val firstEven = nums.first { it%2==0 }

// count
val totalNums = nums.count()
val evenCount = nums.count {it%2==0}

// partition 隔断
// ([6, -4], [1, 3, 5, 3, -3])
val evenOdd = nums.partition { it%2 ==0 }

// minOrNull和maxOrNull函数返回集合中最小和最大的元素。如果集合为空，则返回null。
val numbers = listOf(1, 2, 3)
val empty = emptyList<Int>()
val only = listOf(3)

// 排序sorted
val shuffled = listOf(5, 4, 2, 1, 3, -10)
val natural = shuffled.sorted()
// 取负数后排序
val inverted = shuffled.sortedBy { -it }
// 顺序
val descending = shuffled.sortedDescending()
val descendingBy = shuffled.sortedByDescending { kotlin.math.abs(it) }

// getOrElse
val get1 = nums.getOrElse(1){56}
val get100 = nums.getOrElse(100){200}

fun main() {
    println("positives is $postNums")
    println(tripled)

    println(anyPost)
    println(allEven)
    println(allLess6)

    println(firstEven)

    println()
    println(evenOdd)
    println(evenOdd.first)

    println("Numbers: $numbers, min = ${numbers.minOrNull()} max = ${numbers.maxOrNull()}")
    println("Empty: $empty, min = ${empty.minOrNull()}, max = ${empty.maxOrNull()}")
    println("Only: $only, min = ${only.minOrNull()}, max = ${only.maxOrNull()}")

    println(get100)
}

---

总结

1.kt里的集合List，Set，Map，可变集合和不可变集合；

2.list集合支持的各种方法，类似于Java里面的流stream；