我报名参与金石计划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快速运用第四阶段(集合相关框架)

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