我报名参与金石计划1期挑战——瓜分10万奖池,这是我的第7篇文章,点击查看活动概况
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)
}