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

gujunhe

已于 2022-09-23 23:00:35 修改

阅读量202

点赞数 2

分类专栏： kotlin基础文章标签： kotlin android java

于 2022-09-18 23:13:26 首次发布

本文链接：https://blog.csdn.net/lbsssss/article/details/126923009

版权

kotlin基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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

Kotlin语言的可变Map集合学习

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

Kotlin语言的定义类与field关键字学习

class KtBase70 {
    var name = "Derry"
        get() = field
        set(value) {
            field = value
        }
    /* 背后做的事情：

       @NotNull
       private String name = "Derry";

       public void setName( @NotNull String name) {
            this.name = name;
       }

       @NotNull
       public String getName() {
            return this.name;
       }

     */

    var value = "ABCDEFG"
        // 下面的隐式代码，不写也有，就是下面这个样子
        get() = field
        set(value) {
            field = value
        }

    var info = "abcdefg ok is success"
        get() = field.capitalize() // 把首字母修改成大写
        set(value) {
            field = "**【$value】**"
        }
    /* 背后做的事情：

        @NotNull
        private String info = "abcdefg ok is success";

        public void setInfo( @NotNull String info) {
            this.info = "**【" + info + "】**";
        }

        @NotNull
        public String getInfo() {
            return StringKt.capitalize(this.info)
        }

     */
}

// public final class KtBase70Kt { 下面的main函数 }

fun main() {
    // 背后隐式代码：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语言的计算属性与防范竞态条件

class KtBase71 {
    val number : Int = 0
    /* 背后的代码：

       private int number = 0;

       public int getNumber() {
            return this.number;
       }

     */

    // 计算属性  下面这样写 get函数覆盖了 field 内容本身，相当于field失效了，无用了，以后用不到了
    val number2 : Int
        get() = (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，请检查代码..."
    }
}

// TODO 71.Kotlin语言的 计算属性 与 防范竞态条件
fun main() {
    // 背后隐式代码：System.out.println(new KtBase71().getNumber());
    println(KtBase71().number)

    // 背后隐式代码：new KtBase71().setNumber(9);
    // KtBase71().number = 9 // val 根本就没有 setXXX函数，只有 getXXX函数

    // 背后隐式代码：System.out.println(new KtBase71().getNumber2());
    println(KtBase71().number2)

    // 背后隐式代码：System.out.println(new KtBase71().getShowInfo());
    println(KtBase71().getShowInfo())
}

Kotlin语言的主构造函数学习

// 主构造函数：规范来说，都是增加_xxx的方式，临时的输入类型，不能直接用，需要接收下来 成为变量才能用
// _name 等等，都是临时的类型，不能直接要弄，需要转化一下才能用
class KtBase72(_name: String, _sex: Char, _age: Int, _info: String) // 主构造函数
{
    var name = _name
        get() = field // get不允许私有化
        private set(value) {
            field = value
        }

    val sex = _sex
        get() = field
        // set(value) {} 只读的，不能修改的，不能set函数定义

    val age: Int = _age
        get() = field + 1

    val info = _info
        get() = "【${field}】"

    fun show() {
        // println(_name) 临时的输入类型，不能直接用，需要接收下来 成为变量才能用
        println(name)
        println(sex)
        println(age)
        println(info)
    }
}

// TODO 72.Kotlin语言的主构造函数学习
fun main() {
    // KtBase72()

    val p = KtBase72(_name = "Zhangsan", _info = "学习KT语言", _age = 88, _sex = 'M')
    // println(p.name)
    // p.name = "AAA" 被私有化了，不能调用

    p.show()
}

Kotlin语言的主构造函数里定义属性

/* 伪代码：

class KtBase73 (_name: String, _sex: Char, _age: Int, _info: String)
{
    var name = _name
    val sex = _sex
    val age = _age
    var info = _info

    fun show() {
        println(name)
    }
}

 */

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

// TODO 73.Kotlin语言的主构造函数里定义属性
fun main() {
    KtBase73(name = "Zhangsan", info = "学习KT语言", age = 88, sex = 'M').show()
}

Kotlin语言的次构造函数学习

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

// TODO 74.Kotlin语言的次构造函数学习
// name: String, sex: Char, age: Int, info: String
fun main() {
    val p = KtBase74("李元霸") // 调用主构造

    KtBase74("张三", '男') // 调用 2个参数的次构造函数

    KtBase74("张三2", '男', 88) // 调用 3个参数的次构造函数

    KtBase74("张三3", '男', 78, "还在学校新语言") // 调用 4个参数的次构造函数
}

Kotlin语言的构造函数中默认参数学习

class KtBase75(name: String = "李元霸") // 主构造
{
    // 2个参数的次构造函数，必须要调用主构造函数
    constructor(name: String = "李连杰", sex: Char = 'M') : this(name) {
        println("2个参数的次构造函数 name:$name, sex:$sex")
    }

    // 3个参数的次构造函数，必须要调用主构造函数
    constructor(name: String = "李小龙", sex: Char = 'M', age: Int = 33) : this(name) {
        println("3个参数的次构造函数 name:$name, sex:$sex, age:$age")
    }

    // 4个参数的次构造函数，必须要调用主构造函数
    constructor(name: String = "李俊", sex: Char = 'W', age: Int = 87, info: String = "还在学校新开发语言") : this(name) {
        println("4个参数的次构造函数 name:$name, sex:$sex, age:$age, info:$info")
    }
}

// TODO 75.Kotlin语言的构造函数中默认参数学习
fun main() {
    val p = KtBase75("李元霸2") // 调用主构造

    KtBase75("张三", '男') // 调用 2个参数的次构造函数

    KtBase75("张三2", '男', 88) // 调用 3个参数的次构造函数

    KtBase75("张三3", '男', 78, "还在学校新语言") // 调用 4个参数的次构造函数

    KtBase75() // 到底是调用哪一个 构造函数，是次构造 还是 主构造 ？ 答：优先调用主构造函数
}

Kotlin语言的初始化块学习

/*class A {

    {

    }

    A() {

    }

}*/

// 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) // 用不了，必须要二次转换，才能用
    }
}

// TODO 76.Kotlin语言的初始化块学习
// 1.name,age,sex的主构造函数
// 2.init代码块学习 require
// 3.临时类型只有在 init代码块才能调用
fun main() {
    KtBase76("李四", userage = 88, usersex = '女')  // 调用主构造
    println()
    KtBase76("王五") // 调用次构造

    // KtBase76("") // 调用次构造

    // KtBase76("李四", userage = -1, usersex = 'M')  // 调用主构造

    KtBase76("李四", userage = 1, usersex = '男')  // 调用主构造
}

在这里插入图片描述

Kotlin语言的构造初始化顺序学习

// 第一步：生成val sex: Char
class KtBase77(_name: String, val sex: Char) // 主构造
{

    // 第二步： 生成val mName  // 由于你是写在 init代码块前面，所以先生成你， 其实类成员 和 init代码块 是同时生成
    val mName = _name

    init {
        val nameValue = _name // 第三步：生成nameValue细节
        println("init代码块打印:nameValue:$nameValue")
    }

    // 次构造 三个参数的  必须调用主构造
    constructor(name: String, sex: Char, age: Int) :this(name, sex) {
        // 第五步：生成次构造的细节
        println("次构造 三个参数的, name:$name, sex:$sex, age:$age")
    }

    // 第四步
    val derry = "AAA"

    // 纠正网上优秀博客的错误： 类成员先初始生成   再init代码块初始生成  错误了
    // Derry正确说法：init代码块 和 类成员 是同时的，只不过你写在 init代码块前面 就是先生成你
}

// TODO 77.Kotlin语言的构造初始化顺序学习
// 1.main 调用次构造 name sex age
// 2.主构造的 val 变量
// 3.var mName = _name
// 4.init { nameValue 打印 }
fun main() {
    // 调用次构造
    KtBase77("李元霸", '男', 88)  // 调用次构造
}

Kotlin语言的延迟初始化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("你都没有初始化加载，你是不是忘记加载了")
        }
    }
}

// TODO 78.Kotlin语言的延迟初始化lateinit学习
// 1.lateinit responseResultInfo 定义
// 2.request 懒加载
// 3.showResponseResult
// 4.main 先请求 在显示
fun main() {
    val p = KtBase78()

    // 使用他之前，加载一下（用到它才加载，就属于，懒加载）
    p.loadRequest()

    // 使用他
    p.showResponseResult()
}

Kotlin语言的惰性初始化by lazy学习

class KtBase79 {

    // >>>>>>>>>>>>>>>>>>> 下面是 不使用惰性初始化 by lazy  普通方式(饿汉式 没有任何懒加载的特点)
    // val databaseData1 = readSQlServerDatabaseAction()

    // >>>>>>>>>>>>>>>>>>> 使用惰性初始化 by lazy  普通方式
    val databaseData2 by lazy { readSQlServerDatabaseAction() }

    private fun readSQlServerDatabaseAction(): String {
        println("开始读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("加载读取数据库数据中....")
        println("结束读取数据库数据中....")
        return "database data load success ok."
    }

}

// TODO 79.Kotlin语言的惰性初始化by lazy学习
// 1.不使用惰性初始化 databaseData1 = readSQLServerDatabaseAction()
// 2.使用惰性初始化  databaseData2 by lazy
// 3.KtBase82()  睡眠  db1.databaseData1

// lateinit 是在使用的时候，手动加载的懒加载方式，然后再使用
// 惰性初始化by lazy  是在使用的时候，自动加载的懒加载方式，然后再使用
fun main() {
    // >>>>>>>>>>>>>>>>>>> 下面是 不使用惰性初始化 by lazy  普通方式(饿汉式 没有任何懒加载的特点)
    /*val p = KtBase79()

    Thread.sleep(5000)

    println("即将开始使用")

    println("最终显示:${p.databaseData1}")*/


    // >>>>>>>>>>>>>>>>>>> 使用惰性初始化 by lazy  普通方式
    val p = KtBase79()

    Thread.sleep(5000)

    println("即将开始使用")

    println("最终显示:${p.databaseData2}")

}

Kotlin语言的初始化陷阱一学习

class KtBase80 {

    var number = 9

    init {
        number = number.times(9)
    }

}

// TODO 80.Kotlin语言的初始化陷阱一学习
fun main() {
    println(KtBase80().number)
}

Kotlin语言的初始化陷阱二学习

class KtBase81 {

    val info: String

    init {
        info = "DerryOK"
        getInfoMethod()
        // info = "DerryOK"
    }

    fun getInfoMethod() {
        println("info:${info[0]}")
    }

}

// TODO 81.Kotlin语言的初始化陷阱二学习
// 1.定义info
// 2.init getInfo
// 3.info = ""
fun main() {
    KtBase81().


        getInfoMethod()
}

Kotlin语言的.初始化陷阱三学习

class KtBase82 (_info: String) {
    private val info = _info

    val content : String = getInfoMethod()

    // private val info = _info // 把这种 转换info的代码，写到最前面，这样保证，就不会出现这种问题

    private fun getInfoMethod() = info // 当此函数调用info变量的时候，你以为是赋值好了，但是还没有赋值
}

// TODO 82Kotlin语言的.初始化陷阱三学习
// 1.主构造 _info 放后面
// 2.value = initInfoActin() 放前面
// 3.p.value.length
fun main() {
    println("内容的长度是:${KtBase82("Derry").content.length}")
}