Kotlin学习笔记（三）——集合

小白笔记（持续更新中）

list的创建与元素获取

fun main() {
    val list = listOf("小明", "小李", "小朱")
    //普通取值方式: 索引 内部是运算符重载 [] == get
    println(list[0])
    println(list[2])
    println(list[3])  //下标越界 报错
    //防止奔溃取值方式: getOrElse  getOrNull+空合并操作符一起使用
    //开发过程中，尽量使用getOrElse getOrNull进行元素获取 避免出现空指针异常，下标越界的问题
    println(list.getOrElse(0){"越界了"})
    println(list.getOrElse(5555){"越界了"})
    println(list.getOrNull(0)?:"你越界了")
    println(list.getOrNull(5555)?:"你越界了")
}

mutable list可变集合与list不可变集合

fun main() {
    //mutableListOf 可变集合
    val list= mutableListOf("Marry","Derry","Peter")
    list.add("Candy")
    list.remove("Marry")
    println(list)
    //不可变集合  不能进行list.add  list.remove等操作
    val list1 = listOf("Candy", "Derry", "Peter")
    //可变集合转为不可变集合
    list.toList()
    //不可变集合转为可变集合
    list1.toMutableList()
}

mutator(+= -=)与removeIf

fun main() {
    val list= mutableListOf("Marry","Derry","Peter","王五")
    //mutator的特性 += -=  其实就是运算符重载
    list+="李四"
    list-="王五"
    println(list)
    
    //removeIf 自动遍历整个可变集合 如果满足true则移除  反之不移除
    list.removeIf{true}  //全部被移除
    list.removeIf{it.contains("y")}  //满足包含y的元素将被移除
    println(list)
}

List集合遍历

fun main() {
    val list= listOf(5,6,3,1,4,8,9)
    println(list)  //输出list详情而已 并不是遍历集合
    
    //第一种 遍历方式:
    for (j in list){
        println("$j")
    }
    //第二种 遍历方式:
    list.forEach {
        println("$it")
    }
    //第三种 遍历方式(包括元素与下标): 
    list.forEachIndexed { index, item ->
        println("下标: $index,内容: $item")
    }
}

解构语法过滤元素

fun main() {
    val list= listOf("Marry","Derry","Peter","王五")
    val(v1,v2,v3) =list
    var(vl1,vl2,vl3) =list //可读可写
    vl1="Dask"
    println("$v1,$v2,$v3")
    println("$vl1,$vl2,$vl3")
    //val(n1,_,n3) _不是变量名 是用来过滤解构赋值的，不接收赋值
    val(n1,_,n3) =list
    println("$n1,$n3")
}

set创建与元素获取

fun main() {
    val set= setOf("Marry","Derry","Peter","王五","王五")
    println(set)  //会自动去掉重复的元素
    //set[0] 没有这样[]的功能
    println(set.elementAt(0))  //获取set集合元素 类似于list的 list.get(0)
    println(set.elementAt(3))
//    println(set.elementAt(4))  //越界 会崩溃
    //尽量使用 elementAtOrElse  elementAtOrNull+空合并操作符
    println(set.elementAtOrElse(0) { "越界" })
    println(set.elementAtOrElse(1000) { "你越界了" })
    println(set.elementAtOrNull(0) ?: "set越界")
    println(set.elementAtOrNull(880) ?: "你set越界")
}

可变set集合

fun main() {
    //mutableSetOf 可变set集合
    val set= mutableSetOf("Marry","Derry","Peter")
    set+="Candy"
    set-="Marry"
    set.add("刘军")
    set.remove("Derry")
    println(set)
}

list转set去重与快捷函数distinct去重

fun main() {
    val list= mutableListOf("Marry","Derry","王五","Peter","王五","Derry")
    //转为set去重
    println(list.toSet())
    //转为set去重转回list集合
    val toList = list.toSet().toList()
    println(toList)
    //distinct 快捷函数去重 源码:this.toMutableSet().toList()
    println(list.distinct())
}

数组的创建与元素获取

fun main() {
    val intArray = intArrayOf(1, 5, 6, 4, 8, 3, 10)
    //数组元素获取
    println(intArray[0])
//    println(intArray[8]) //越界崩溃  报错
    //尽量使用  elementAtOrElse  elementAtOrNull+空合并操作符
    println(intArray.elementAtOrElse(0) { -100 })
    println(intArray.elementAtOrElse(1000) { -100 })
    println(intArray.elementAtOrNull(0) ?: "越界了")
    println(intArray.elementAtOrNull(1000) ?: "你越界了")
    //list转数组
    val list= mutableListOf('A','B','C')
    println(list.toCharArray())
    //arrayOf
    val strings = arrayOf("Marry", "Derry", "王五", "Peter")
    println(strings.toString())
    val fileName = arrayOf(File("Marry"), File("Derry"), File("王五"), File("Peter"))
    println(fileName.toString())
}

Map的创建

fun main() {
    //map的创建 两种方式  等价
    val map:Map<String,Int> = mapOf<String, Int>("Derry" to 55, "Qerry" to 545, "Merry" to 56)
    //Pair（k,v）一对键值
    val map2= mapOf(Pair("derry",55),Pair("Qerry",75),Pair("marry",23))
}

获取Map的value值（四种方式）

fun main() {
    //尽量使用方式二，方式三
    val map:Map<String,Int> = mapOf<String, Int>("Derry" to 55, "Qerry" to 545, "Merry" to 56)
    //方式一:找不到会返回null
    println(map["Derry"])
    println(map.get("Derry")) //get与[] 等价
    println(map["D"])  //map通过key找value 如果找不到就返回null,不会崩溃
    //方式二:getOrDefault
    println(map.getOrDefault("Derry", -1))
    println(map.getOrDefault("Derry2", -1))
    //方式三:getOrElse
    println(map.getOrElse("Derry") { -1 })
    println(map.getOrElse("Derry2") { -1 })
    //方式四:  getValue 与java一样 找不到键会崩溃 尽量不使用此方式 源码中会抛出异常
    println(map.getValue("Derry"))
//    println(map.getValue("XXX"))  //找不到 报错
}

遍历Map的四种方式

fun main() {
    val map:Map<String,Int> = mapOf<String, Int>("Derry" to 55, "Qerry" to 545, "Merry" to 56)
    //第一种方式: it== Map中的每一个元素（k,v）
    map.forEach{
        println("${it.key},${it.value}")
    }
    println()
    //第二种方式:
    map.forEach { key,value->
        println("$key,$value")
    }
    println()
    //第三种方式:
    map.forEach { (key, value) ->
        println("$key,$value")
    }
    println()
    //第四种方式: val item: Map.Entry<key:String, value:Int>
    for (item in map) {
        println("${item.key},${item.value}")
    }
}

可变Map集合

fun main() {
    //mutableMapOf 可变Map集合的创建
    val map= mutableMapOf("Derry" to 55, "Qerry" to 545, "Merry" to 56)
    map += "Karry" to 789
    map += "Oarry" to(74)
    map -= "Merry"
    map["Larry"]=963
    map.put("Tarry",852)  //put 和 [] 等价的
    //getOrPut  在整个map中找不到key元素，就会先添加key，value (123) 元素到map中，然后再从map中获取
    val value = map.getOrPut("Jarry") { 123 }
    println(value)
    println(map["Jarry"])
    //如果在整个map中找到了key元素,直接返回它的value值
    println(map.getOrPut("Derry") { 123 })
}