Kotlin基础语法四

• List创建与元素获取常用方法

    val list = listOf("AA", "BB", "CC", "DD")// 普通取值方式：    索引  内部是运算符重载 [] == getprintln(list[0])println(list[1])println(list[2])println(list[3])// println(list[4]) // 奔溃  java.lang.ArrayIndexOutOfBoundsException: 4println()// 我们写KT代码，一定不会再出现，空指针异常，下标越界异常// 防止奔溃取值方式： getOrElse getOrNullprintln(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的亮点

• mutator函数
  -Kotlin 中的 ‌mutator 函数‌ 是专门用于修改可变集合（如 MutableList、MutableSet 等）内容的成员函数或操作符，其核心特点是直接改变集合内部状态而非返回新集合。

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

• List集合遍历

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

• 解构语法过滤元素

   // 解析参数不能超过5，不能作为全局变量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")

• Set创建与元素获取

    val set: Set<String> = setOf("AA", "BB", "CC", "DD")println(set.elementAt(0)) // [0]println(set.elementAtOrElse(0) {"越界了"})println(set.elementAtOrNull(0))

• 可变Set集合

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

• 集合转换与快捷函数

   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)// 快捷函数去重 distinctprintln(list.distinct()) // 内部做了：先转变成 可变的Set结合  在转换成 List集合println(list.toMutableSet().toList()) // 和上面代码等价

• 数组类型

/*Kotlin语言中的各种数组类型，虽然是引用类型，背后可以编译成Java基本数据类型IntArray        intArrayOfDoubleArray     doubleArrayOfLongArray       longArrayOfShortArray      shortArrayOfByteArray       byteArrayOfFloatArray      floatArrayOfBooleanArray    booleanArrayOfArray<对象类型>           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 elementAtOrNullprintln(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"))
}

• ma的创建

    val mMap1 : Map<String, Double> = mapOf<String, Double>("key1" to(534.4), "key2" to 454.5)val mMap2 = mapOf(Pair("key1", 545.4), Pair("key2", 664.4))

• map的遍历

    val map /*: Map<String, Int>*/ = mapOf(Pair("AA", 123), Pair("BB", 456), "CC" 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}")}

• Map遍历

    val map /*: Map<String, Int>*/ = mapOf(Pair("AA", 123), Pair("BB", 456), "CC" 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}")}

• 可变Map集合

    // 1.可变集合的操作 += [] putval map : MutableMap<String, Int> = mutableMapOf(Pair("Derry", 123), "Kevin" to 456, Pair("Dee", 789))// 下面是可变操作map += "AAA" to(111)map += "BBB" to 1234map -= "Kevin"map["CCC"] = 888map.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)

• 定义类与field关键字学习

    var name = "KK"get() = fieldset(value) {field = value}var value = "ABCDEFG"// 下面的隐式代码，不写也有，就是下面这个样子get() = fieldset(value) {field = value}var info = "abcdefg ok is success"get() = field.capitalize() // 把首字母修改成大写set(value) {field = "**【$value】**"}// 背后隐式代码：new KtBase70().setName("Kevin");KtBase70().name = "Kevin"// 背后隐式代码：System.out.println(new KtBase70().getName());println(KtBase70().name)println(">>>>>>>>>>>>>>>>>>")// 背后隐式代码：System.out.println(new KtBase70().getInfo());println(KtBase70().info)// 背后隐式代码：new KtBase70().setInfo("学习KT");KtBase70().info = "学习KT"

• Kotlin语言的 计算属性 与 防范竞态条件

    val number : Int = 0/* 背后的代码：private int number = 0;public int getNumber() {return this.number;}*/// 计算属性  下面这样写 get函数覆盖了 field 内容本身，相当于field失效了，无用了，以后用不到了val number2 : Intget() = (1..1000).shuffled().first() // 从1到1000取出随机值 返回给 getNumber2()函数/*背后隐式代码：为什么没有看到 number2 属性定义？答：因为属于 计算属性 的功能，根本在getNumber2函数里面，就没有用到 number2属性，所以 number2属性 失效了，无用了，以后用不到了public int getNumber2() {return (1..1000).shuffled().first()java的随机逻辑 复杂 ;}*/var info: String ? = null // ""// 防范竞态条件  当你调用成员，这个成员，可能为null，可能为空值，就必须采用 防范竞态条件，这个是KT编程的规范化fun getShowInfo() : String {// 这个成员，可能为null，可能为空值，就启用 防范竞态条件// 这种写法，就属于 防范竞态条件，我们可以看到专业的KT开发者，有大量这种代码// also永远都是返回 info本身return info?.let {if (it.isBlank()) {"info你原来是空值，请检查代码..." // 是根据匿名函数最后一行的变化而变化} else {"最终info结果是:$it" // 是根据匿名函数最后一行的变化而变化}} ?: "info你原来是null，请检查代码..."}

• 主构造函数

class KtBase72(_name: String, _sex: Char, _age: Int, _info: String) // 主构造函数
{var name = _nameget() = field // get不允许私有化private set(value) {field = value}val sex = _sexget() = field// set(value) {} val只读的，不能修改的，不能set函数定义val age: Int = _ageget() = field + 1val info = _infoget() = "【${field}】"fun show() {// println(_name) 临时的输入类型，不能直接用，需要接收下来 成为变量才能用println(name)println(sex)println(age)println(info)}
}

• 主构造函数里定义属性

// var name: String  就相当于  var name = _name  这不过你看不到而已
// 一步到位，不像我们上一篇是分开写的
class KtBase73 (var name: String, val sex: Char, val age: Int, var info: String)
{fun show() {println(name)println(sex)println(age)println(info)}
}

• 次构造函数

class KtBase74(name: String) // 主构造
{// 2个参数的次构造函数，必须要调用主构造函数，否则不通过，  为什么次构造必须调用主构造？答：主构造统一管理 为了更好的初始化设计constructor(name: String, sex: Char) : this(name) {println("2个参数的次构造函数 name:$name, sex:$sex")}// 3个参数的次构造函数，必须要调用主构造函数constructor(name: String, sex: Char, age: Int) : this(name) {println("3个参数的次构造函数 name:$name, sex:$sex, age:$age")}// 4个参数的次构造函数，必须要调用主构造函数constructor(name: String, sex: Char, age: Int, info: String) : this(name) {println("4个参数的次构造函数 name:$name, sex:$sex, age:$age, info:$info")}
}// name: String, sex: Char, age: Int, info: String
fun main() {val p = KtBase74("李元霸") // 调用主构造KtBase74("张三", '男') // 调用 2个参数的次构造函数KtBase74("张三2", '男', 88) // 调用 3个参数的次构造函数KtBase74("张三3", '男', 78, "还在学校新语言") // 调用 4个参数的次构造函数
}

• 初始化

// username: String, userage: Int, usersex: Char  临时类型，必须要二次转换，才能用
class KtBase76 (username: String, userage: Int, usersex: Char) // 主构造
{// 这个不是Java的 static{}// 相当于是Java的 {} 构造代码块// 初始化块  init代码块init {println("主构造函数被调用了 $username, $userage, $usersex")// 如果第一个参数是false，就会调用第二个参数的lambda// 判断name是不是空值 isNotBlank   ""require(username.isNotBlank()) { "你的username空空如也，异常抛出" }require(userage > 0) { "你的userage年龄不符合，异常抛出" }require( usersex == '男' || usersex == '女') { "你的性别很奇怪了，异常抛出" }}constructor(username: String) : this(username, 87, '男') {println("次构造函数被调用了")}fun show() {// println(username) // 用不了，必须要二次转换，才能用}
}

• 延迟初始化lateinit

class KtBase78 {// lateinit val AAA; // AAA 无法后面在修改了，我还怎么延时初始化？lateinit var responseResultInfo: String // 我等会儿再来初始化你，我先定义再说，所以没有赋值// 模拟服务器加载fun loadRequest() { // 延时初始化，属于懒加载，用到你在给你加载responseResultInfo = "服务器加载成功，恭喜你"}fun showResponseResult() {// 由于你没有给他初始化，所以只有用到它，就奔溃// if (responseResultInfo == null) println()// println("responseResultInfo:$responseResultInfo")if (::responseResultInfo.isInitialized) {println("responseResultInfo:$responseResultInfo")} else {println("你都没有初始化加载，你是不是忘记加载了")}}
}

• 惰性初始化by lazy

 var  name  by lazy{"Kotlin"}