Kotlin快速运用第四阶段(集合相关框架)

Kotlin语言的List创建与元素获取学习

// 普通取值方式: 索引
// 防止崩溃取值方式: getOrElse getOrNull

fun main() {
 val list = listOf("Derry", "Zhangsan", "Lisi", "Wangwu")
 // 普通取值方式: 索引 内部是运算符重载 [] == get
 println(list[0])
 println(list[1])
 println(list[2])
 println(list[3])
 // println(list[4]) // 奔溃 java.lang.ArrayIndexOutOfBoundsException: 4
 println()
 // 我们写KT代码,一定不会再出现,空指针异常,下标越界异常
 // 防止奔溃取值方式: getOrElse getOrNull
 println(list.getOrElse(3) {"越界"})
 println(list.getOrElse(4) {"你越界了"})
 println(list.getOrElse(4402) {"你越界了啊"})
 println()
 println(list.getOrNull(1))
 println(list.getOrNull(4))
 println(list.getOrNull(111))
 // getOrNull + 空合并操作符
 println(list.getOrNull(222) ?: "你越界了哦哦")
 // 小结:开发过程中,尽量使用 getOrElse 或 getOrNull,才能体现KT的亮点
}

Kotlin语言的可变List集合学习

// 可变的集合
// 不可变集合 to 可变集合
// 可变集合 to 不可变集合

fun main() {
 // 可变的集合
 val list = mutableListOf("Derry", "Zhangsna", "Wangwu")
 // 可变的集合,可以完成可变的操作
 list.add("赵六")
 list.remove("Wangwu")
 println(list)
 // 不可变集合 to 可变集合
 val list2 = listOf(123, 456, 789)
 // 不可以的集合,无法完成可变的操作
 // list2.add
 // list2.remove
 val list3 : MutableList<Int> = list2.toMutableList()
 // 可变的集合,可以完成可变的操作
 list3.add(111)
 list3.remove(123)
 println(list3)
 // 可变集合 to 不可变集合
 val list4: MutableList<Char> = mutableListOf('A', 'B', 'C')
 // 可变的集合,可以完成可变的操作
 list4.add('Z')
 list4.remove('A')
 println(list4)
 val list5: List<Char> = list4.toList()
 // 不可以的集合,无法完成可变的操作
 /*list5.add
 list5.remove*/
}

Kotlin语言的mutator函数学习

// 1.mutator += -= 操作
// 2.removeIf

fun main() {
 // 1.mutator += -= 操作
 val list : MutableList<String> = mutableListOf("Derry", "DerryAll", "DerryStr", "Zhangsan")
 list += "李四" // mutator的特性 += -+ 其实背后就是 运算符重载而已
 list += "王五"
 list -= "Derry"
 println(list)
 // 2.removeIf
 // list.removeIf { true } // 如果是true 自动变量整个可变集合,进行一个元素一个元素的删除
 list.removeIf { it.contains("Derr") } // 过滤所有的元素,只要是有 Derr 的元素,就是true 删除
 println(list)
}

Kotlin语言的List集合遍历学习

fun main() {
 val list = listOf(1, 2, 3, 4, 5, 6, 7)
 println(list) // 输出list详情而已,这个不是遍历集合
 // 第一种 遍历方式:
 for (i in list) {
 print("元素:$i ")
 }
 println()
 // 第二种 遍历方式:
 list.forEach {
 // it == 每一个元素
 print("元素:$it ")
 }
 println()
 // 第三种 遍历方式:
 list.forEachIndexed { index, item ->
 print("下标:$index, 元素:$item ")
 }
}

Kotlin语言的解构语法过滤元素学习

// 1.集合配合解构语法
// 2.反编译看Java给三个变量赋值的代码
// 3.解构屏蔽接收值

fun main() {
 val list: List<String> = listOf("李元霸", "李小龙", "李连杰")
 val(value1, value2, value3) = list
 // value1 = "" val只读的
 println("value1:$value1, value2:$value2, value3:$value3")
 var(v1, v2, v3) = list
 // v1 = "OK"
 println("v1:$v1, v2:$v2, v3:$v3")
 // 用_内部可以不接收赋值,可以节约一点性能
 val(_ , n2, n3) = list
 // println(_) _不是变量名,是用来过滤解构赋值的,不接收赋值给我
 println("n2:$n2, n3:$n3")
}

Kotlin语言的Set创建与元素获取

// 1.set 定义 不允许重复
// 2.普通方式elementAt 会越界奔溃
// 3.elementAtOrElse elementAtOrNull

fun main() {
 val set: Set<String> = setOf("lisi", "wangwu", "zhaoliu", "zhaoliu") // set集合不会出现重复元素的
 println(set)
 // set[0] 没有这样 [] 的功能 去Set集合元素
 println(set.elementAt(0)) // [0]
 println(set.elementAt(1))
 println(set.elementAt(2))
 // println(set.elementAt(3)) // [3] 奔溃 会越界
 // println(set.elementAt(4)) // [4] 奔溃 会越界
 println()
 // 使用 list 或 set 集合,尽量使用 此方式,防止越界奔溃异常
 println(set.elementAtOrElse(0) {"越界了"})
 println(set.elementAtOrElse(100) {"越界了了"})
 println(set.elementAtOrNull(0))
 println(set.elementAtOrNull(111))
 // OrNull + 空合并操作符 一起使用
 println(set.elementAtOrNull(88) ?: "你越界啦啊")
}

Kotlin语言的可变Set集合

fun main() {
 val set : MutableSet<String> = mutableSetOf("李元霸", "李连杰")
 set += "李俊"
 set += "李天"
 set -= "李连杰"
 set.add("刘军")
 set.remove("刘军")
 println(set)
}

Kotlin语言的集合转换与快捷函数学习

// 1.定义可变list集合
// 2.List 转 Set 去重
// 3.List 转 Set 转 List 也能去重
// 4.快捷函数去重 distinct


fun main() {
 val list : MutableList<String> = mutableListOf("Derry", "Derry", "Derry", "Leo", "Lance") // list 可以重复元素
 println(list)
 // List 转 Set 去重
 val set /*: Set<String>*/ = list.toSet()
 println(set)
 // List 转 Set 转 List 也能去重
 val list2 /*: List<String>*/ = list.toSet().toList()
 println(list2)
 // 快捷函数去重 distinct
 println(list.distinct()) // 内部做了:先转变成 可变的Set结合 在转换成 List集合
 println(list.toMutableSet().toList()) // 和上面代码等价
}

Kotlin中的数组类型

/*
 Kotlin语言中的各种数组类型,虽然是引用类型,背后可以编译成Java基本数据类型
 IntArray intArrayOf
 DoubleArray doubleArrayOf
 LongArray longArrayOf
 ShortArray shortArrayOf
 ByteArray byteArrayOf
 FloatArray floatArrayOf
 BooleanArray booleanArrayOf
 Array<对象类型> arrayOf 对象数组
*/
// 1.intArrayOf 常规操作的越界奔溃
// 2.elementAtOrElse elementAtOrNull
// 3.List集合转 数组
// 4.arrayOf Array<File>
fun main() {
 // 1.intArrayOf 常规操作的越界奔溃
 val intArray /*: IntArray*/ = intArrayOf(1, 2, 3, 4, 5)
 println(intArray[0])
 println(intArray[1])
 println(intArray[2])
 println(intArray[3])
 println(intArray[4])
 // println(intArray[5]) // 奔溃:会越界异常
 println()
 // 2.elementAtOrElse elementAtOrNull
 println(intArray.elementAtOrElse(0) { -1 })
 println(intArray.elementAtOrElse(100) { -1 })
 println(intArray.elementAtOrNull(0))
 println(intArray.elementAtOrNull(200))
 // OrNull + 空合并操作符 一起来用
 println(intArray.elementAtOrNull(666) ?: "你越界啦啊啊啊")
 println()
 // 3.List集合转 数组
 val charArray /*: CharArray*/ = listOf('A', 'B', 'C').toCharArray()
 println(charArray)
 // 4.arrayOf Array<File>
 val objArray /*: Array<File>*/ = arrayOf(File("AAA"), File("BBB"), File("CCC"))
}

Kotlin语言的Map的创建

fun main() {
 val mMap1 : Map<String, Double> = mapOf<String, Double>("Derry" to(534.4), "Kevin" to 454.5)
 val mMap2 = mapOf(Pair("Derry", 545.4), Pair("Kevin", 664.4))
 // 上面两种方式是等价的哦
}

Kotlin语言的读取Map的值

// 方式一 [] 找不到会返回null
// 方式二 getOrDefault
// 方式三 getOrElse
// 方式四 与Java一样 会奔溃

fun main() {
 val mMap /*: Map<String, Int>*/ = mapOf("Derry" to 123,"Kevin" to 654)
 // 方式一 [] 找不到会返回null
 println(mMap["Derry"]) // 背后对[] 运算符重载了
 println(mMap["Kevin"])
 println(mMap.get("Kevin")) // get 与 [] 完完全全等价的
 println(mMap["XXX"]) // map通过key找 如果找不到返回null,不会奔溃
 println()
 // 方式二 getOrDefault
 println(mMap.getOrDefault("Derry", -1))
 println(mMap.getOrDefault("Derry2", -1))
 // 方式三 getOrElse
 println(mMap.getOrElse("Derry") {-1})
 println(mMap.getOrElse("Derry2") {-1})
 println()
 // 方式四 getValue 与Java一样 会奔溃 尽量不要使用此方式
 println(mMap.getValue("Derry"))
 println(mMap.getValue("XXX"))
 // map获取内容,尽量使用 方式二 方式三
}

Kotlin语言的遍历Map学习

// 四种方式遍历
fun main() {
 val map /*: Map<String, Int>*/ = mapOf(Pair("Derry", 123), Pair("Kevin", 456), "Leo" to 789)
 // 第一种方式:
 map.forEach {
 // it 内容 每一个元素 (K 和 V) 每一个元素 (K 和 V) 每一个元素 (K 和 V)
 // it 类型 Map.Entry<String, Int>
 println("K:${it.key} V:${it.value}")
 }
 println()
 // 第二种方式:
 map.forEach { key: String, value: Int ->
 // 把默认的it给覆盖了
 println("key:$key, value:$value")
 }
 println()
 // 第三种方式:
 map.forEach { (k /*: String*/, v /*: Int*/) ->
 println("key:$k, value:$v")
 }
 println()
 // 第四种方式:
 for (item /*: Map.Entry<String, Int>*/ in map) {
 // item 内容 每一个元素 (K 和 V) 每一个元素 (K 和 V) 每一个元素 (K 和 V)
 println("key:${item.key} value:${item.value}")
 }
}

Kotlin语言的可变Map集合学习

// 1.可变集合的操作 += [] put
// 2.getOrPut 没有的情况
// 3.getOrPut 有的情况

fun main() {
 // 1.可变集合的操作 += [] put
 val map : MutableMap<String, Int> = mutableMapOf(Pair("Derry", 123), "Kevin" to 456, Pair("Dee", 789))
 // 下面是可变操作
 map += "AAA" to(111)
 map += "BBB" to 1234
 map -= "Kevin"
 map["CCC"] = 888
 map.put("DDD", 999) // put 和 [] 等价的
 // 2.getOrPut 没有有的情况
 // 如果整个map集合里面没有 FFF的key 元素,我就帮你先添加到map集合中去,然后再从map集合中获取
 val r: Int = map.getOrPut("FFF") { 555 }
 println(r)
 println(map["FFF"]) // 他已经帮你加入进去了,所以你可以获取
 // 3.getOrPut 有的情况
 val r2 = map.getOrPut("Derry") {666} // 发现Derry的key是有的,那么就直接获取出来, 相当于666备用值就失效了
 println(r2)
}
作者:havenobug

%s 个评论

要回复文章请先登录注册