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)
}