Kotlin快速运用第四阶段(集合相关框架)
2024-05-08 15:54:06
Kotlin语言的List创建与元素获取学习
// 普通取值方式： 索引
// 防止崩溃取值方式： getOrElse getOrNull
fun main() {val list = listOf("Derry", "Zhangsan", "Lisi", "Wangwu")// 普通取值方式： 索引 内部是运算符重载 [] == 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的亮点
}
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.removeval 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.addlist5.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)// 快捷函数去重 distinctprintln(list.distinct()) // 内部做了：先转变成 可变的Set结合 在转换成 List集合println(list.toMutableSet().toList()) // 和上面代码等价
}
Kotlin中的数组类型
/*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"))
}
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)// 方式一 [] 找不到会返回nullprintln(mMap["Derry"]) // 背后对[] 运算符重载了println(mMap["Kevin"])println(mMap.get("Kevin")) // get 与 [] 完完全全等价的println(mMap["XXX"]) // map通过key找 如果找不到返回null，不会奔溃println()// 方式二 getOrDefaultprintln(mMap.getOrDefault("Derry", -1))println(mMap.getOrDefault("Derry2", -1))// 方式三 getOrElseprintln(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.可变集合的操作 += [] 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)
}
Kotlin语言的可变Map集合学习
fun main() {// 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)
}
Kotlin语言的定义类与field关键字学习
class KtBase70 {var name = "Derry"get() = fieldset(value) {field = value}/* 背后做的事情：@NotNullprivate String name = "Derry";public void setName( @NotNull String name) {this.name = name;}@NotNullpublic String getName() {return this.name;}*/var value = "ABCDEFG"// 下面的隐式代码，不写也有，就是下面这个样子get() = fieldset(value) {field = value}var info = "abcdefg ok is success"get() = field.capitalize() // 把首字母修改成大写set(value) {field = "**【$value】**"}/* 背后做的事情：@NotNullprivate String info = "abcdefg ok is success";public void setInfo( @NotNull String info) {this.info = "**【" + info + "】**";}@NotNullpublic 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 : 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，请检查代码..."}
}// 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 = _nameget() = field // get不允许私有化private set(value) {field = value}val sex = _sexget() = field// set(value) {} 只读的，不能修改的，不能set函数定义val age: Int = _ageget() = field + 1val info = _infoget() = "【${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 = _nameval sex = _sexval age = _agevar info = _infofun 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 = _nameinit {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 = 9init {number = number.times(9)}}// TODO 80.Kotlin语言的初始化陷阱一学习
fun main() {println(KtBase80().number)
}
Kotlin语言的初始化陷阱二学习
class KtBase81 {val info: Stringinit {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 = _infoval 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}")
}
Kotlin快速运用第四阶段(集合相关框架)相关推荐
- Kotlin基本语法（四）-集合
1.List 获取元素的两种方式: 普通元素获取:list[0] 防崩溃方式获取:list.getOrElse()list.getOrNull() fun main() {val list = lis ...
- Kotlin学习记录（四）—— 常用集合的使用
接上篇: Kotlin学习记录(三)-- 子线程获取数据,实现简单ListView 集合在程序中的比例的很重的,Kotlin针对集合进行了更加简洁和有效的封装,这边文章就简单的介绍一下list,map ...
- python数据分析的四阶段以及电商数据描述性分析和探索性分析
目录 数据分析的四阶段 1 需求 数据情况 需求 产出 2 数据规整(数据预处理,数据清洗,数据重构) 2.1 数据预处理 2.1.1 发现错误的对策 2.1.2 修正缺失值 2.2 修正错误数据 方 ...
- 五分钟了解GRE是什么，四信GRE相关应用推荐
随着互联网新技术的发展以及智能化水平的提高,各企业对实时数据传输的需求也在不断提升,企业愈发重视数据中心的建设,各类虚拟网络技术相继被引入.今天,我们重点了解下云端"借道"鼻祖,善 ...
- c++有哪四个类型转换相关的关键字
[面试题]c++有哪四个类型转换相关的关键字? 在C/C++语言中用 (type) value(在C++还可以采用type(value))来进行显式类型转换(explicit type convers ...
- STL源码学习----集合相关算法
STL一共提供了四种与集合相关的算法,分别是并集(union), 交集(intersection),差集(difference),对称差集(symmetric difference). 这四种集合算法 ...
- 【JAVA SE】第十四章 集合框架、语法糖和泛型
第十四章 集合框架.语法糖和泛型 文章目录 第十四章 集合框架.语法糖和泛型 一.集合框架 1.概念 2.接口 二.语法糖 1.概念 2.解语法糖 三.泛型 1.概念 2.泛型类 3.泛型接口 4.泛 ...
- Unity快速入门之四 - Unity模型动画相关
最近要给公司的小伙伴做Unity入门,针对几个常用的知识进行快速入门介绍. Unity快速入门之一 3D基础概念.Camera.Canvas RenderMode的几种方式对比_翕翕堂 Unity快速 ...
- 转载 web前端进阶四阶段
前端工程的四个阶段 转载自:http://www.cnblogs.com/lanlanlan00/p/7155663.html 写在前面:引用别人的,在我看来说得比较浅显易懂的. 现在的前端开发倒也并 ...
最新文章
- 在VS中用正则表达式查找或替换
- Single molecule real-time (SMRT) sequencing comes of age: applications and utilities for medical dia
- 32拟合分析_SigmaPlot14.5：指导用户逐步完成图形创建和数据分析过程
- 51nod 1287: 加农炮 好题啊好题
- linux shell脚本 报错dirname：无效选项 -- b 错误原因 解决方法
- LA3135简单多路归并（优先队列）
- oracle最新scn补丁,更新：Oracle全面修正了关于DB Link和SCN补丁的公告
- 查看IE浏览器安装的插件
- How to resolve ATC error message Package Violation (Error) - Missing Use Access (USEM)
- java高分面试指南：java单例模式双重检查
- python使用turtle步骤_Python+turtle交互式绘图：可以用鼠标拖动的小海龟
- sftp工具都有哪些_公众号怎么排版？公众号排版都会用到哪些工具？
- socket编程（九）
- 为何python不好找工作-不会Python迟早失业?Python何以成为找工作必备技能
- an argument for principle #1:thoreau's new economics 36-38
- EPIVAN | 基于预训练和注意力机制的启动子增强子相互作用预测
- 国内算法竞赛平台汇总
- C#语言实例源码系列-实现Linq操作Xml
- 2019年信息安全工程师上午真题及答案解析
- 实验（1）信号的采样