手机触屏网站制作软件,企业网站轮播图,kfk wordpress,文登网站建设声明
大家好#xff0c;这里是懒羊羊学长#xff0c;如果需要pdf版以及其他资料#xff0c;请加入群聊。群里每天更新面经、求职资料#xff0c;经验分享等#xff0c;大家感兴趣可以加一下。 Kotlin 声明1.Kotlin基础2. Kotlin函数3.Kotlin进阶4.Kotlin集合5.Kotlin高…声明
大家好这里是懒羊羊学长如果需要pdf版以及其他资料请加入群聊。群里每天更新面经、求职资料经验分享等大家感兴趣可以加一下。 Kotlin 声明1.Kotlin基础2. Kotlin函数3.Kotlin进阶4.Kotlin集合5.Kotlin高级6.kotlin实战6.1协变 逆变 7. 手写内置函数7.1 Kotlin的单例模式7.2 Kotlin的注解7.3 手写RxJava 1.Kotlin基础
Kotlin的空指针检查 var name:String?null//村民1使用null//TODO 第一种补救措施变量后边加上?,这样的话name如果真的是null后边就不会执行就不会引发空指针异常name?.length//TODO 第二种补救措施不论name是不是null都会执行name!!.length//TODO 第三种补救措施 (和Java一样)if(name!null){name.length}
var 和val //TODO val修饰的变量只读不能改 var修饰的变量可读可改 我们修饰变量时尽可能用val修饰类型推断函数也可以类型推断
fun main(){//TODO 类型推断val name:StringDerryval info:String 真的很帅val name1Derryval age35val sexc//kotlin在编译期就决定好了类型那么他就是静态语言。
}
fun add(number1:Int,number2:Int)number1number2Java中称为方法kotlin中称为函数可以写在类的外面 Kotlin内置数据类型 这些在Java里边相当于一个包装类 String 字符串 Char 单字符 Boolean true、false Int 整数 Double 小数 List 元素集合 Set 无重复的元素集合 Map 键值对的集合 编译时常量
const val PI3.14 //编译时常量不能放在函数里边。如果在函数里边的话只能在运行时运行何来编译时常量之说。
fun main(){val infoValueDerry is Ok //这个是只读类型的变量并不能成为编译时常量println(infoValue)//只能读取只读类型}kotlin引用数据类型
const val PI3.14 //编译时常量不能放在函数里边。如果在函数里边的话只能在运行时运行何来编译时常量之说。
fun main(){val infoValueDerry is Ok //这个是只读类型的变量并不能成为编译时常量println(infoValue)//只能读取只读类型}range表达式
package com.example.myapplication.kotlinlearn
//TODO kotlinrange表达式讲解
class kt13 {}
fun main(){val number148//range 范围从哪里到哪里if(number in 10..59){println(分数不及格)}else if(number in 0..9){println(分数不及格并且分数很差)}else if (number in 60..100){println(分数合格)}else if (number !in 0..100){println(分数不在1到100范围内)}
}when表达式
package com.example.myapplication.kotlinlearn//TODO when表达式详解
class kt14 {
}fun main() {//Java中if语句是执行代码//Kotlin中是表达式能够有返回值val week 1val resultInfo when (week) {1 - 星期一2 - 星期二3 - 星期三4 - 星期四5 - 星期五6 - 星期六7 - 星期日else - 不知道星期几了}println(resultInfo)
}String模板
package com.example.myapplication.kotlinlearnclass kt15 {
}//TODO 15.String 模板
fun main() {val garden 梅溪湖公园val time 6println(今天天气很晴朗去玩 garden 玩了 time 小时)//Java的写法println(今天天气很晴朗去玩$garden玩了${time}小时)//String模板的写法//KT是表达式println()val isLogin falseprintln(resposne result:${if (isLogin) 恭喜 else 不恭喜})
}2. Kotlin函数
函数格式
package com.example.myapplication.kotlinlearn02class K1Base {
}//TODO 16.Kotlin的函数头讲解
fun main() {method01(1, 33)
}//函数不加修饰符的话默认就是public
//kotlin函数是先有输入再有输出
private fun method01(age: Int, name: String): Int {println(name$name,age:$age)return 200
}默认参数
package com.example.myapplication.kotlinlearn02class K1Base {
}//TODO 16.Kotlin的函数头讲解
fun main() {method01(1, 33)
}//函数不加修饰符的话默认就是public
//kotlin函数是先有输入再有输出
private fun method01(age: Int, name: String): Int {println(name$name,age:$age)return 200
}具名函数参数
package com.example.myapplication.kotlinlearn02class K1Base {
}//TODO 16.Kotlin的函数头讲解
fun main() {method01(1, 33)
}//函数不加修饰符的话默认就是public
//kotlin函数是先有输入再有输出
private fun method01(age: Int, name: String): Int {println(name$name,age:$age)return 200
}Unit关键字
package com.example.myapplication.kotlinlearn02class kt19 {
}//TODO KotlinUnit函数的特点
fun main() {val r: Unit doWork()println(r)}//:Unit不写默认也有相当于无参数返回 忽略类型 相当于Java里的voidUnit是一个类型 不是关键字
private fun doWork(): Unit {}Nothing关键字
package com.example.myapplication.kotlinlearn02class kt19 {
}//TODO KotlinUnit函数的特点
fun main() {val r: Unit doWork()println(r)}//:Unit不写默认也有相当于无参数返回 忽略类型 相当于Java里的voidUnit是一个类型 不是关键字
private fun doWork(): Unit {}反引号的使用
package com.example.myapplication.kotlinlearn02
//TODO kotlin反引号特点讲解class kt21 {
}private fun a() {//1 方法名 用反引号写的kotlin方法名在低版本的时候是可以使用的但先高版本已经废弃了kt21.is()//如果别的Java文件里恰好定义了这两个方法那么得用反引号括起来kt21.in()//3.第三种情况//private fun 2123456(){ 加密函数作用维护一个文档里边写明这个函数的饿作用////}}private fun 2123456() {}匿名函数
package com.example.myapplication.kotlinlearn02//TODO 22.匿名函数讲解
fun main() {//没有名字的函数是匿名函数val length derry.count() {// 由于没有名字会默认给这个Char类型一个名字一般情况下 都是it。传入参数是把字符串的每一个字符依次传入进来it r}println(length) //这里会打印出2因为字符串中只有两个字符是满足lambda表达式的条件}Kotlin函数类型
package com.example.myapplication.kotlinlearn02class kt23 {
}//TODO 23.Kotlin的函数类型和隐式返回讲解
fun main() {val methodAction: () - String//函数的输入与输出的声明 声明区域methodAction { //实现区域xyr //匿名函数不用写return 以最后一行作为返回值}//调用函数println(methodAction())println(methodAction.invoke()) //这种调用方式仅限于lambda普通函数就不支持这种方式了
}fun methodAction(): String //声明区域
{return xyz //实现区域
}lambda函数的参数
package com.example.myapplication.kotlinlearn02fun main() {//第一步函数输入 输出 和声明,第二步是函数的实现val methodAction: (Int, Int, Int) - String { number1, number2, number3 - //大括号里是函数的实现number1:$number1,number2:$number2}//第三步调用println(methodAction(1, 2, 3))
}//真正的函数
fun methodAction(number1: Int, number2: Int, number3: Int) {}it关键字的用法
package com.example.myapplication.kotlinlearn02fun main() {//第一步函数输入 输出 和声明,第二步是函数的实现val methodAction: (Int, Int, Int) - String { number1, number2, number3 - //大括号里是函数的实现number1:$number1,number2:$number2}//第三步调用println(methodAction(1, 2, 3))
}//真正的函数
fun methodAction(number1: Int, number2: Int, number3: Int) {}匿名函数类型推断
package com.example.myapplication.kotlinlearn02//TODO 26.Kotlin的匿名函数类型自动推断
fun main() {//val fun2: () - Unit//fun1 必须指定参数类型和返回类型val fun1 {println(你好)}//如果没有指定则以最后一行作为返回值类型val fun3 { v1: Double, v2: Float, v3: Int -啦啦啦v1$v1,v2$v2,v3$v3}//fun3 就是(Double,Float,Int)-String 这个类型 ,fun4并不是匿名函数只是一个变量后边的函数体才是匿名函数println(fun3(2.2, 3f, 5))fun1.invoke()
}lambda表达式
package com.example.myapplication.kotlinlearn02//TODO 27.Kotlin的lambda的表达式
fun main() {//匿名函数val fun1 {}//匿名函数等价于后边要讲的Lambdaval addResultFun { number1: Int, number2: Int -println(两个数相加的结果是${number1 number2})}val weekResult: (Int) - Any { number: Int -when (number) { //when关键字也可以作为一个返回值1 - 星期一else - -1}}
}函数中定义参数是函数包函数
package com.example.myapplication.kotlinlearn02//TODO 28.函数中定义参数是函数包函数
fun main() {//用户loginAPI(Derry, 123456) { msg, code -println(用户最终登录的成果如下msg:$msg,code是:$code)}
}//模拟数据库SQLServer
const val USER_NAME_SAVE_DB Derry
const val USER_PWD_SAVE_DB 123456//模拟登录API前端
public fun loginAPI(userName: String, userPwd: String, responseResult: (String, Int) - Unit) {if (userName null || userPwd null) {TODO(用户名密码是null)}responseResult.invoke(userName, 3)
}内联函数
package com.example.myapplication.kotlinlearn02//TODO 内联函数
fun main() {//TODO 如果函数没有内联那么在调用端会生成多个对象来完成Lambda的调用会造成性能的损耗//TODO 如果此函数使用内联在调用端会采用宏替换替换到调用处好处没有任何函数开辟、对象开辟等性能的损耗//如果一个函数里的参数有Lambda那么就需要声明内联//TODO 如果函数参数有Lambda尽量使用inline修饰这样内部会做优化减少函数、对象开辟的损耗。
}函数引用
package com.example.myapplication.kotlinlearn02//TODO 31,函数引用类型调用
fun main() {//方式一login(张三, 123) { msg, code -{}//函数引用环节 函数通过函数引用来变成函数类型的对象login(张三, 李四, ::responseResultImp)}
}fun responseResultImp(msg: String, pwd: Int): Unit {}inline fun login(name: String, pwd: String, resposneResult: (String, Int) - Unit) {}Kotlin中函数类型作为返回值类型
package com.example.myapplication.kotlinlearn02//TODO 32.Kotlin的函数类型作为返回类型
fun main() {val result showFun(你好)//result是个函数类型result(dd, 3)}fun show(info: String): Boolean { //函数返回Boolean值return false;
}fun showFun(info: String): (String, Int) - String {println(我是show函数info:$info)return { name, age -name$name,age${age}}
}匿名函数和具名函数
package com.example.myapplication.kotlinlearn02//TODO 33.Kotlin中的匿名函数和具名函数
fun main() {//匿名函数showPersonInfo(Derry, 38, 男, 学习KT语言中) {println(it)}println()//具名函数showPersonInfo(Derry, 38, 男, 学习KT语言中, ::showResultImpl)}fun showResultImpl(it: String) {println(显示具名$it)
}inline fun showPersonInfo(name: String,age: Int,sex: Char,study: String,showResult: (String) - Unit
) {val str name:$name,age:$age,sex:$sex,study:$studyshowResult(str)//这个lambda只是起了一个名字并不是一个真正的函数真正的实现是上边的println语句}kotlin可空的特性
package com.example.myapplication.kotlinlearn03//TODO 34.Kotlin语言可空性的特点
fun main() {//TODO name不能为空如果为空编译会报错var name: String Derry//TODO 第二种情况 声明的时候指定为可空var name2: String? Derryhelloname2 nullprintln(name2?.length)//如果name2为null就不执行后边的区域
}kotlin安全调用操作符
package com.example.myapplication.kotlinlearn03import androidx.compose.ui.text.AnnotatedString
import androidx.compose.ui.text.capitalize//TODO 35.Kotlin语言的安全调用操作符
fun main() {var name: String? xuyuanzhival c name?.capitalize() //name是可空类型可能是null如果想要使用name必须给出补救措施//如果name是Null就不会执行后边的区域代码所以就不会崩溃。println(c)
}Kotlin中带let的安全调用
package com.example.myapplication.kotlinlearn03//TODO 36.kotlin中使用带let的安全调用
fun main() {val name: String? null//如果name真的是null就不执行?.let{}这一大块区域的代码var r name?.let {// itname本身所以是String类型的if (it.isBlank()) {Default} else {[$it]}}println(r)
}Kotlin中的非空断言操作符
package com.example.myapplication.kotlinlearn03import androidx.compose.ui.text.capitalize//TODO 37.Kotlin语言中的非空断言操作符
fun main() {var name: String? nullname!!.capitalize()//!!是断言不管name是不是null都会执行.capitalize()所以就报空指针异常了所以要慎用//结论如果百分百能够保证name是有值的才能使用!!(否则有Java空指针异常)否则进来使用
}if判断null值的情况
package com.example.myapplication.kotlinlearn03//TODO kotlin中使用if判断Null值情况
fun main() {var name: String? null//if(补救措施)if (name ! null) {var r name.capitalize()println(r)} else {println(name is null)}
}Kotlin的空合并操作符
package com.example.myapplication.kotlinlearn03//TODO kotlin中使用if判断Null值情况
fun main() {var name: String? null//if(补救措施)if (name ! null) {var r name.capitalize()println(r)} else {println(name is null)}
}异常处理与自定义异常
package com.example.myapplication.kotlinlearn03//TODO kotlin中使用if判断Null值情况
fun main() {var name: String? null//if(补救措施)if (name ! null) {var r name.capitalize()println(r)} else {println(name is null)}
}kotlin中先决条件函数
package com.example.myapplication.kotlinlearn03//TODO 41.kotlin中的先决条件函数
fun main() {val value1: String? nullvar value2: Boolean falsecheckNotNull(value1) //抛个异常requireNotNull(value1)//require(value2) {println(我是傻逼)}}
kotlin中的substring
package com.example.myapplication.kotlinlearn03
//TODO 42.Kotlin中的substringconst val INFO xyz is Success
fun main() {val indexOf INFO.indexOf(i)println(INFO.substring(0, indexOf))println(INFO.substring(0 until indexOf))
}43 kotlin中的split操作
package com.example.myapplication.kotlinlearn03//TODO 43.Kotlin语言的split操作
fun main() {val jsonText x1,x2,x3,x4val list: ListString jsonText.split(,)println(分割后的list里面的元素有${list})list.forEach {println(it)}//C解构 KT也有解构val (v1: String, v2, v3, v4) listprintln($v1,$v2,$v3,$v4)
}kotlin中使用repace完成加密解密的操作
package com.example.myapplication.kotlinlearn03//TODO 44.Kotlin中的replace完成加密解码操作
fun main() {val sourcePwd AbcdefdsAKMNOfafadfaggprintln(原始密码为:$sourcePwd)val newPwd sourcePwd.replace(Regex(AKMNO)) {-}println(newPwd)//解密操作val sourcePwdNew newPwd.replace(Regex([-])) {when (it.value) {- - AKMNOelse - it.value}}println(解密后的密码为$sourcePwdNew)
}kotlin中和的比较
package com.example.myapplication.kotlinlearn03//TODO 45.Kotlin中 与的比较
fun main() {// 是内容的比较。相当于Java的equals//是引用的比较val n1: String aaaval n2: String aaaprintln(n1.equals(n2))println(n1 n2)println(n1 n2)
}kotlin中字符串的遍历操作
package com.example.myapplication.kotlinlearn03//TODO 46.Kotlin中字符串的遍历操作
fun main() {val str abcdefgstr.forEach {println(字符是$it)}
}Kotlin中数字类型安全转换操作符
package com.example.myapplication.kotlinlearn03//TODO 47.Kotlin中数字类型的安全转换函数
fun main() {val number: Int 666.toInt()println(number)//如果转换成Int成功就返回Int如果转换失败就返回Nullval number2: Int? 666.6.toIntOrNull()println(number2)
}Double与Int类型相互转化
package com.example.myapplication.kotlinlearn03import kotlin.math.roundToInt//TODO 48.Double转Int与类型格式化
fun main() {println(65.4.toInt()) //toInt没有四舍五入的效果是取低位的println(66.8.roundToInt())//roundToInt有四舍五入的效果”%“val r: String %.3f.format(66.5554511)//后边保留小数点后三位println(r)
}3.Kotlin进阶
apply函数的用法
package com.example.myapplication.kotlinlearn03import androidx.compose.ui.text.toLowerCase//TODO 49.Kotlin中apply的内置函数
fun main() {val info Derry is successful//普通传统方式println(info.length)println(info的最后一个字符是${info[info.length - 1]})println(info全部转化成小写${info.toLowerCase()})//apply方式info.apply {//一般大部分情况下匿名函数都会持有一个it但是apply不会持有it但会持有this thisinfo本身//apply函数始终是返回info本身String类型println(this)println(length)println(info的最后一个字符是${this[length - 1]})println(info全部转化成小写${this.toLowerCase()})}//TODO apply函数的写法规则如下//apply函数始终返回info本身所以可以进行链式调用info.apply {println(info的长度是${this.length})}.apply {println(info的最后一个字符是${this[length - 1]})}.apply {println(info全部转化成小写${this.toLowerCase()})println(readLine())}//TODO 结论 apply的返回值 谁.apply返回谁本身//apply里没有it只有thisthisxxx本身//TODO 用法使用中不需要用apply的返回值而是尽量使用链式调用功能分层
}let函数
package com.example.myapplication.kotlinlearn03//TODO 50.kotlin语言let的内置函数
//普通方式 对集合第一个元素相加
//let方式 对集合第一个元素相加
//普通方式 对值判null 并返回
//let方式 对值判null 并返回
fun main() {val list: ListInt listOf(1, 2, 3, 4)val value1 list.first()println(value1 value1)//TODO let方式对集合第一个元素相加listOf(1, 2, 3, 4).let {//it 集合本身//let作为内置函数会以最后一行作为返回值it.first() it.first()}//TODO apply总结//1.apply函数的返回类型 永远是调用者本身//2. apply函数的匿名函数体{持有的是thisinfo本身}//TODO let总结// 1.let函数的返回值是 函数最后一行的返回值// let函数持有的是itit等于调用者本身//TODO 普通方式对值判null 并返回//TODO let解决对值判null 并返回}fun get(value: String?): String {return value?.let { //如果value为null 则不会执行函数体里的东西如果不为null 则执行:后边的东西欢迎${value}回来} ?: 你传递的是null
}//简化版本
fun get2(value: String?) value?.let { //如果value为null 则不会执行函数体里的东西如果不为null 则执行:后边的东西欢迎${value}回来
} ?: 你传递的是nullrun函数的综合案例
package com.example.myapplication.kotlinlearn03//TODO 51.Kotlin语言中run内置函数
fun main() {//1.run函数的特点 字符串演示val str xyz is successful//TODO run函数的返回根据匿名函数str.run {//以最后一行作为返回值,run函数函数体持有thisthis调用者本身a}//TODO 2.具名函数判断长度//这个是匿名函数str.run {}//这个是具名函数配合runstr.run(::isLong) //thisstr.run(::showText) //thisisLong函数返回类型Boolean的值本身.run(::mapTest).run {println(this)}println()//TODO 上面的函数全部是具名函数调用给run运行str.run {if (length 5) true else false}.run {if (this) 你的字符串合格 else 你的字符串不合格}.run {$this}.run {println(this)}}fun isLong(str: String) if (str.length 5) true else false
fun showText(isLong: Boolean) if (isLong) 你的字符串合格 else 你的字符串不合格fun mapTest(str: String) [$str]
with操作符
package com.example.myapplication.kotlinlearn03//TODO 52.kotlin中with函数
fun main() {//TODO 和run函数是一模一样 持有thisval n1 hellowith(n1) {//thisstr本身}val result1: Int with(n1, ::getStrLenAction)val result2: String with(n1, ::getStrInfo)//匿名操作with(with(n1) {n1.length}) {你的字符串长度为$this}}fun getStrLenAction(str: String) str.lengthfun getStrInfo(str: String) stralso的用法
package com.example.myapplication.kotlinlearn03import androidx.compose.ui.text.toLowerCase//TODO also操作符
// str.also和apply差不多永远是返回调用者本身
fun main() {val str XUYUANZHIval r1: String str.also {}.also {//可以链式调用it a}str.also {println(str的原始值是$it)}.also {println(str转换成小写的效果是${it.toLowerCase()})}
}takeif操作符
package com.example.myapplication.kotlinlearn03//TODO 54.takeIf海曙的使用
fun main() {val name: String? aaval result name.takeIf {false}//如果为true这个表达式返回name本身如果为false则返回nullprintln(result)//企业用法takeif空合并操作符name.takeIf { true } ?: 权限不够被拒绝访问
}//TODO 总结一般大部分情况下都是takeIf空合并操作符
takeunless函数
package com.example.myapplication.kotlinlearn03//TODO 55.takeUnless
fun main() {aaa.takeUnless {false} ?: 未经过任何初始化的值//takeUnless和takeif判断条件相反但是效果一样//false会返回调用者本身true会返回null
}4.Kotlin集合
list的创建与获取
package com.example.myapplication.kotlinlearn03//TODO 56.Kotlin语言的list创建与元素获取
fun main() {val list: ListString listOf(张三, 李四, 王五)//普通取值方式 ,索引println(list[0])println(list[1])println(list[2])println(list.get(0))println(list.get(1))println(list.getOrElse(2) { 越界 })println(list.getOrElse(3) { 越界了 })println(list.getOrNull(20))println(list.getOrNull(2333) ?: 你越界了哦)//总结开发过程中尽量使用getOrElse 或者 getOrNull 才能体现出Kotlin中的亮点
}可变list集合的学习
package com.example.myapplication.kotlinlearn03//TODO 57.Kotlin可变List集合学习
fun main() {val list: MutableListString mutableListOf(Derry, zhangsan, lisi)//可变的集合list.add(赵六)list.remove(lisi)println(list)//不可变集合val list2: ListInt listOf(123, 456, 789)println(list2)//不可变转为可变集合val list3: MutableListInt list2.toMutableList()//可变集合变为不可变集合val list4 list3.toList() //无法完成可变的操作//小结KT语言中分为可变集合与不可变集合 Kotlin中更加推荐使用不可变集合防止造成数据丢失
}mutator学习
package com.example.myapplication.kotlinlearn03//TODO 58.Kotlin语言的mutator函数学习
fun main() {//1.mutator -操作val list: MutableListString mutableListOf(Derry, DerryAll, zhangsan, lisi)list 张三list - 李四println(list)//2.removeIf
// list.removeIf{ //如果是true自动遍历整个可变集合一个一个元素的删除
// true
// }list.removeIf {it.contains(D) //过滤包含D的元素}println(list)
}list集合的遍历
package com.example.myapplication.kotlinlearn03//TODO 59.List集合遍历学习
fun main() {val mList: ListInt listOfInt(1, 2, 3, 4, 5, 6)println(mList)//输出list详情而已不是遍历集合//第一种遍历for (item: Int in mList) {println(item:$item)}//第二种遍历mList.forEach {//it每一个元素println(item:$it)}//第三种方式mList.forEachIndexed { index, i -println(下标是$index,值是$i)}
}kotlin中解构语法过滤元素学习
package com.example.myapplication.kotlinlearn04//TODO 60.Kotlin语言解构语法过滤元素学习
fun main() {val list: ListString listOf(李元霸, 李小龙, 李连杰)var (v1, v2, v3) listvar (_, va1, va2) list //_不是变量是用来过滤结构赋值的拒收值不接收赋值给我
}61Set元素的创建与获取
package com.example.myapplication.kotlinlearn04//TODO 61.Kotlin中Set创建与元素获取
//set 定义不允许重复
//
fun main() {val set: SetString setOf(张三, 李四, 王五, 李四)println(set)println(set.elementAt(0))println(set.elementAt(3))//越界 会崩溃println()println(set.elementAtOrElse(3) { 越界了 })println(set.elementAtOrNull(3)) //得不到会返回null}可变集合set
package com.example.myapplication.kotlinlearn04fun main() {val set: MutableSetString mutableSetOf(李元霸, 李连杰)set 张三set - 李四set.remove(王五)
}Kotlin集合转换和快捷函数学习
package com.example.myapplication.kotlinlearn04//TODO 63.Kotlin语言集合转换和快捷函数学习
fun main() {//1.定义可变list集合val list: MutableListString mutableListOf(张三, 李四, 王五)println(list)//2.list转set自动去重val set: SetString list.toSet()println(set)//4.快捷函数去重distinctprintln(list.distinct())
}Kotlin中的数组类型
package com.example.myapplication.kotlinlearn04
//TODO 64.Kotlin中的数组类型
// IntArray inArrayOf
// DoubleArray doubleArrayOffun main() {val intArray intArrayOf(1, 2, 3, 4)println(intArray[1])println(intArray.elementAtOrNull(0) ?: aaa)//尽量不会崩溃//OrNull要配合空合并操作符来使用println(intArray.elementAtOrElse(55) { 3 })//TODO 3.List集合转数组listOfChar(a, b, c, d).toCharArray()}map集合
package com.example.myapplication.kotlinlearn04import androidx.compose.animation.scaleOut//TODO 65.Kotlin中Map的创建
fun main() {//第一种方式val map1: MapString, Double mapOfString, Double(xuyuanzhi to 22.3, lal to 33.3)//第二种方式val map2 mapOf(Pair(aaa, 33.2), Pair(ddd, 22.5))//TODO 读取map的值println(map1[xuyuanzhi])//运算符重载了println(map1.get(xuyuanzhi))//运算符重载//方式二println(map1.getOrDefault(xuyuanzhi, -1))println(map1.getOrDefault(xuyuanzhi) { -1 })//方式三和Java一样获取不到会崩溃println(map1.getValue(xuyuanzhi))//TODO 遍历map的值//第一种方式map2.forEach {// it 每一个元素都是一个mapkey value 结构。 it类型为 Map.EntryString,Intprintln(K:${it.key},V:${it.value})}println()//第二种方式map2.forEach { key: String, value: Double - //把it覆盖了println(key是$value,value 是 $value)}//第三种方式map2.forEach { (key: String, value: Double) -println(key 是$key,value是$value)}//第四种方式for (item: Map.EntryString, Double in map2) {println(${item.key},value是${item.value})}//TODO 可变集合Map的操作val map3: MutableMapString, Int mutableMapOf(Pair(Derry1, 123), Pair(xuyuanzhi, 456))map3 aaa to 23map3 BBB to 45map3 - Derrymap3[cc] 888map3.put(Dddd, 999)//如果在map里没有找到999的元素那么先把999添加到里边去然后再从map里边获取999的元素map3.getOrPut(999) {66}println(map3)}Kotlin的计算属性与防范竞态条件
package com.example.myapplication.kotlinlearn04//TODO 70.Kotlin语言的计算属性与防范竞态条件
class Derry {val number: Int 0get() field//计算属性 field 永远是描述name的值,如果一个变量没有赋值那么就没有field这个东西。//TODO 防范静态条件 当你调用成员这个成员可能为null可能为空值就必须采用防范竞态条件这个是KT编程的规范化// 防范静态条件尽量使用(?内置函数空合并操作符)var info: String? nullfun getStudentInfo(): String {return info?.let { //info如果不为null则执行let函数里的如果为null则执行?:后边的语句if (it.isBlank()) {你原来是空值} else {$it}} ?: info你原来是null请检查代码}//
}fun main() {//val修饰的变量 没有set函数Derry().number// 计算属性}kotlin的主构造函数
package com.example.myapplication.kotlinlearn04//主构造函数规范来说都是增加_xxx的方式临时的输入类型不能直接用需要接收下来成为变量才能用
class Students(_name: String, _age: Int) {val name: String _namefun show() {println(nieg)}
}//TODO 71.Kotlin语言的主构造函数学习
fun main() {val student Students(张三, 56)
}Kolin中的构造函数
package com.example.myapplication.kotlinlearn04class Student2(var name: String, var age: Int) { //主构造函数 推荐这样写//如果想完成多个构造函数重载的话就用次构造才能做到//次构造函数必须调用主构造函数否则编译不通过constructor(name: String) : this(name, 33) {}//三个参数的构造函数constructor(name: String, age: Int, sex: Char) : this(name, 33) {}}//TODO 构造函数的默认参数
// 主构造和次构造都有默认参数时优先使用主构造然后再使用次构造
class Animal(name: String 啦啦啦) {val name nameoverride fun toString(): String {println(ddd)return aa}
}fun main() {val s1 Student2(张三, 18, 男) //调用三个参数的构造函数首先会去先调用主构造函数然后调用次构造函数val a1 Animal()println(a1.toString())
}类的初始化顺序 package com.example.myapplication.kotlinlearn03//TODO 76.Kotlin语言构造初始化顺序学习
fun main() {//重点Init代码块和类成员是同时生成的
}lateinit学习 延迟初始化
package com.example.myapplication.kotlinlearn04//TODO 77.Kolin里边延迟初始化lateinit学习
class kt77 {lateinit var name: String;fun show() {if (::name.isInitialized) {//判断name有没有初始化}}//TODO 我们再使用延迟初始化字段的时候一定要用::name.isInitialized 这个来判断因为这个字段一碰就会崩溃所以不要随便用
}fun main() {}by lazy 的使用
package com.example.myapplication.kotlinlearn04class k78 {val database: String by lazy {aaa //只有用的时候才会加载}
}//TODO 78.惰性初始化by lazy
// lateinit 是在使用的时候手动加载的懒加载方式然后再使用
// by lazy 是在使用的时候自动加载的懒加载方式然后再使用
fun main() {}崩溃小陷阱
package com.example.myapplication.kotlinlearn04class kt79(_info: String) {val content: String getInfoMethod()private val info _infoprivate fun getInfoMethod() info
}//TODO 1.陷阱一如果init函数里要用到类属性那么属性初始化要放在init函数之前
// 2.陷阱二 类后边的函数要用到变量要在这个函数之前进行初始化
// 3.陷阱三
// 总结为了以后不出现陷阱三所有的类成员都放到最前面就好了
fun main() {println(${kt79(Derry).content.length}) //会崩因为执行先执行构造方法然后执行getInfoMentod这个时候info还没有初始化所以会崩}5.Kotlin高级
继承与重载的open关键字
package com.example.myapplication.kotlinlearn05import androidx.compose.animation.scaleOut
import com.example.myapplication.kotlinlearn04.Student2// public final class Person
// open 去除 final修饰open class Person(private val name: String) { //构造参数私有化子类不可访问private fun showName() 父类的名字是$namefun showName1() 父类的名字是$nameopen fun myPrintln(): Unit println(showName())
}class Student(private val subName: String) : Person(subName) {private fun showName() 子类的名字是$subNameoverride fun myPrintln(): Unit println(showName()) //此函数以及被子类重写了}//TODO 82.Kotlin的继承与重载的open关键字
fun main() {val person: Person Student(aa)person.myPrintln()println(person is Person)println(person is Student)// is as 配合来使用if (person is Student) {// (person as Person).myPrintln() 这个就算转换到父类也是调用到子类的方法println((person as Person).showName1())}}Kotlin类型转换
package com.example.myapplication.kotlinlearn05class kt84 {
}fun main() {//智能类型转换// xxx as xxx 从一个类型转换到另一个类型
}Kotlin中Any类的超类
package com.example.myapplication.kotlinlearn05//TODO 85.Kotlin的Any超类
// 在kt中所有的类都隐式继承了Any你不写默认就有
// 在Java中所有的类都隐式集成了 extends Object,你不写 默认就有
// Any在Kotlin设计中只提供标准看不到实现实现在各个平台处理好了
class Person3 {}fun main() {}Kotlin对象声明
package com.example.myapplication.kotlinlearn05object kt86 {/*object 对象类背后做了什么public static final K86 INSTANCE;private K86() {} //主构造废除一样的效果static {K86 var0new k86()INSTANCE var0//直接把init代码搬到这里来了因为主构造函数被私有化所以把东西搬到这里来了String var1K86 init...System.out.println(var1)}public final void show(){}*/
}//TODO 86.Kotlin的对象声明
fun main() {}Kotlin中的对象表达式
package com.example.myapplication.kotlinlearn05open class kt87 {open fun add(info: String) println(K87 add: $info)open fun del(info: String) println(K87 del: $info)
}//TODO 87.Kotlin的对象表达式
fun main() {//TODO 匿名 对象表达式方式val p1: kt87 object : kt87() {override fun add(info: String) {println(我是匿名表达方式$info)}override fun del(info: String) {println(我是匿名表达方式:$info)}}p1.add(aaa)p1.del(ddd)val p2: kt87 k87Impl()p2.add(张三)p2.del(李四)//TODO 对Java的接口 用对象表达式方式val p3: Runnable object : Runnable {override fun run() {println(Java Runnable run...)}}p3.run()val p4: Runnable Runnable { //Kotlin不支持这种简洁方式只有Java可以println(aaa)}p4.run()}class k87Impl : kt87() {override fun add(info: String) {println(我是具名函数add$info)}override fun del(info: String) {println(我是具名函数del${info})}
}kotlin中的伴生对象
package com.example.myapplication.kotlinlearn05class kt88 {companion object {//伴生对象 本身是一个静态内部类val name 许远志 //直接会生成静态的 private static final String name许远志”val info lalala是吧fun showInfo() println(显示:$info)// public static final kt88.companion companion new kt88.companion()//给外界调用的}
}//TODO 88.Kotlin的伴生对象
// 伴生对象很大程度上和Java的static静态差不多的 不管kt88实例化多少次伴生对象只加载一次 伴生对象只初始化一次
fun main() {}内部类
package com.example.myapplication.kotlinlearn05//TODO 内部类
class Body() { //外部类val name: String aaaclass Heart { //嵌套类 加上inner修饰符才能变成内部类 val nameHeart: String bbbfun show() {//println(name)}}
}//嵌套类的特点外部的类能访问内部的嵌套类 内部的嵌套类不能访问外部类的成员
// 内部类的特点 内部的类能访问外部的类 外部的类能访问内部的类
class kt89 {inner class kt899 {}
}fun main() {//内部类kt89().kt899()//嵌套类Body.Heart()}Kotlin的数据类
package com.example.myapplication.kotlinlearn05//普通类
class ResponseResultBean(var msg: String, var code: Int, var data: String) : Any()//TODO set get 构造函数
//相当于接收 服务器返回的JavaBean 现在kotlin叫做数据类
data class ResponseResultBean2(var msg: String, var code: Int, var data: String) : Any()//TODO set get 构造函数 copy 克隆 toString hashCode equals 结论数据类 生成更加丰富
//TODO 90.Kotlin的数据类
fun main() {//TODO 1.ToString方法println(ResponseResultBean(aa, 12, aa))//普通类 toString 调用了windows打印的toStringprintln(ResponseResultBean2(aa, 12, aa))// 数据类 any重写了父类的toString//TODO 2.方法//普通类的实现 Any父类的实现 是equals 是比较两个对象的引用//数据类是值的比较所以 内容一样就是true//TODO 总结普通类的Any 的 是引用的比较 数据类any的被重写了 是值的比较}Kotlin的解构操作
package com.example.myapplication.kotlinlearn05//普通类
class Student1(var name: String, var age: Int, var sex: Char) {//解构操作 必须从component1开始operator fun component1() nameoperator fun component2() ageoperator fun component3() sex}class kt92 {
}//TODO 92.Kotlin的解构操作
fun main() {var (name, age, sex) Student1(张三, 89, 男)//数据类默认就有解构操作}Kt的运算符重载
package com.example.myapplication.kotlinlearn05
//TODO 93.Kotlin的运算符重载class AddClass(var number1: Int, var number2: Int) {operator fun plus(p1: AddClass) (number1 p1.number1) (number2 p1.number2)}fun main() {//运算符重载println(AddClass(2, 2) AddClass(3, 3))
}枚举类
package com.example.myapplication.kotlinlearn05//枚举的值等于枚举本身
enum class Week {星期一,星期二,}fun main() {}枚举类型定义函数
package com.example.myapplication.kotlinlearn05data class LimbInfo(var limbInfo: String, var length: Int) {fun show() println($limbInfo,长度是 $length)
}enum class Limbs(private var limbsInfo: LimbInfo) {LEFT_HAND(LimbInfo(左手, 88)),//左手RIGHT_HAND(LimbInfo(左手, 88)),//左手; //结束枚举值fun show() 四肢是${limbsInfo.limbInfo} ,长度是${limbsInfo.length}fun update(limbsInfoUpdate: LimbInfo) {this.limbsInfo.limbInfo limbsInfoUpdate.limbInfo //也可以更新枚举值这个枚举值的对象是实例化的时候传进来的}
}//结论枚举的主构造参数必须与枚举值保持一致
// 95.枚举类型定义函数
fun main() {println(Limbs.LEFT_HAND.show()) //枚举值的主构造参数不要管是枚举值直接调用show来显示的}Kotlin的代数数据类型
package com.example.myapplication.kotlinlearn05enum class Exam {Fraction1,//分数差Fraction2,//分数及格Fraction3,//分数良好Fraction4,//分数优秀;//枚举结束
}class Teacher(private val exem: Exam) {fun show() when (exem) {Exam.Fraction1 - 该学生的分数很差Exam.Fraction2 - 该学生的分数及格Exam.Fraction3 - 该学生的分数良好Exam.Fraction4 - 该学生的分数优秀//不需要使用else ,由于我们的函数是用枚举类型来判断处理的这个就属于代数数据类型不需要写else了//因为when表达式非常明确了只有四种类型不会出现else其他所以不需要写}
}//TODO 96.Kotlin的代数数据类型讲解
//定义
fun main() {}密封类
package com.example.myapplication.kotlinlearn05//密封类 :在于控制子类数量可控以免被非法继承
// 枚举类在于控制状态数量可控
//
sealed class kt97 {
}//TODO 97.密封类 我们的成员必须要有类型(object class) 2. 并且是继承本类
fun main() {}数据类使用条件
package com.example.myapplication.kotlinlearn05//TODO 98.数据类使用条件
// 数据类至少必须有一个参数的主构造函数 必须有val var 修饰的参数数据类不能使用abstractinner open 等修饰
fun main() {}6.kotlin实战
接口的定义
package com.example.myapplication.kotlinlearn06interface IUSB {var usbVersionInfo: String //USB版本信息var usbInsertDevice: String// 插入的设备信息fun insertUSB(): String //被插入的动作
}open class Mouse(override var usbVersionInfo: String, override var usbInsertDevice: String) : IUSB {override fun insertUSB(): String {TODO(Not yet implemented)}}class shubiao : Mouse(aa, a), IUSB {override fun insertUSB(): String {return super.insertUSB()}}//TODO 99.Koltin的接口定义详解
// 1.接口里面和接口本身都是public open的所以不需要open
// 2.接口不能有主构造
// 3.实现类不仅仅要重写接口的函数也要重写接口的成员
// 4.接口实现代码区域要加Override来修饰
fun main() {}接口的默认实现只是有这个功能很少使用
package com.example.myapplication.kotlinlearn06interface IUSB2 {val usbVersionInfo: Stringget() 你好小白 //接口的默认实现
}class Mouse2 : IUSB2 {override val usbVersionInfo: Stringget() super.usbVersionInfo
}// TODO 接口的默认实现
fun main() {val iusb: IUSB2 Mouse2()println(iusb.usbVersionInfo)}Kotlin的抽象类
package com.example.myapplication.kotlinlearn06abstract class BaseActivity {fun onCreate() {setContentView(getLayoutID())initView()initData()initXXX()}private fun setContentView(layoutID: Int) println(你好啦啦啦)abstract fun getLayoutID(): Intabstract fun initView()abstract fun initData()abstract fun initXXX()}class MainActivity : BaseActivity() {override fun getLayoutID(): Int {return 1223}override fun initView() {}override fun initData() {}override fun initXXX() {}fun show() super.onCreate()}//TODO 101-Kotlin的抽象类详解
fun main() MainActivity().show()泛型类讲解
package com.example.myapplication.kotlinlearn06abstract class BaseActivity {fun onCreate() {setContentView(getLayoutID())initView()initData()initXXX()}private fun setContentView(layoutID: Int) println(你好啦啦啦)abstract fun getLayoutID(): Intabstract fun initView()abstract fun initData()abstract fun initXXX()}class MainActivity : BaseActivity() {override fun getLayoutID(): Int {return 1223}override fun initView() {}override fun initData() {}override fun initXXX() {}fun show() super.onCreate()}//TODO 101-Kotlin的抽象类详解
fun main() MainActivity().show()内置函数泛型
package com.example.myapplication.kotlinlearn06class kt103T(private val isR: Boolean, private val obj: T) {fun getObj(): T? obj.takeIf { isR }
}//TODO 103.内置函数泛型
fun main() {val s1 Student(张三, 33)println(kt103(true, s1).getObj())println(kt103(false, s1).getObj())kt103(true, s1).getObj().apply {println(this)}!!
}Kotlin泛型变换实战
package com.example.myapplication.kotlinlearn06class kt104T(val isMap: Boolean, val inputType: T) {//false,返回null//true 返回调用者本身inline fun R map(mapAction: (T) - R): R? mapAction(inputType).takeIf { isMap }
}//TODO 104.Kotlin的泛型变换实战’fun main() {val p1: kt104Int kt104(isMap true, inputType 333)val r: String? p1.map {aaa}println(变换后的结果是$r)
}kotlin泛型类的约束 TPerson 这样写的话只有Person 以及Person的子类才可以传进去。 Kotlin抽象类
package com.example.myapplication.kotlinlearn06abstract class BaseActivity {fun onCreate() {setContentView(getLayoutID())initView()initData()initXXX()}private fun setContentView(layoutID: Int) println(你好啦啦啦)abstract fun getLayoutID(): Intabstract fun initView()abstract fun initData()abstract fun initXXX()}class MainActivity : BaseActivity() {override fun getLayoutID(): Int {return 1223}override fun initView() {}override fun initData() {}override fun initXXX() {}fun show() super.onCreate()}//TODO 101-Kotlin的抽象类详解
fun main() MainActivity().show()kotlin中vararg关键字
package com.example.myapplication.kotlinlearn06class kt106T(vararg objects: T, var isMap: Boolean) {//out 我们的T只能被读取不能被修改private val objectArray: Arrayout T objectsfun showObj(index: Int): T? objectArray[index].takeIf { isMap }
}//TODO 106.kotlin的vararg关键字(动态参数)
fun main() {val p kt106(aaa, ddd, isMap true)println(p.showObj(0))println(p.showObj(1))println(p.showObj(2))
}Kotlin的[]操作符
package com.example.myapplication.kotlinlearn06class kt107T(vararg objects: T, var isMap: Boolean) {//out 我们的T只能被读取不能被修改private val objectArray: Arrayout T objectsfun showObj(index: Int): T? objectArray[index].takeIf { isMap }//运算符重载operator fun get(index: Int): T? objectArray[index].takeIf { isMap }
}//TODO 107.Kotlin的[]操作符讲解
fun main() {val p kt107(aaa, ddd, isMap true)p[0]println(p[1])
}6.1协变 逆变
协变讲解
package com.example.myapplication.kotlinlearn06interface Producerout T {//out T 代表此泛型在整个生产者里边 这个T只能被读取不能被修改了fun getT(): T}interface Consumerin T {//消费者 ,只能修改 不能被读取fun consumer(item: T) //只能被修改}//TODO 108.协变讲解-KT
fun main() {//TODO 协变 相当于Java里的? extends Person 这样保证了只能接受 Person以及Person的子类}协变讲解
package com.example.myapplication.kotlinlearn06interface Producerout T {//out T 代表此泛型在整个生产者里边 这个T只能被读取不能被修改了fun getT(): T}interface Consumerin T {//消费者 ,只能修改 不能被读取fun consumer(item: T) //只能被修改}//TODO 108.协变讲解-KT
fun main() {//TODO 协变 相当于Java里的? extends Person 这样保证了只能接受 Person以及Person的子类// 协变 可以在使用处协变 也可以在生命处协变【Java只有在使用处协变】// 逆变 子类去接收父类 in T 相当于Java 里的 ? super Person 这样保证了 能接收Person以及 Person的父类// 总结 协变out 父类 子类// 逆变 in 子类父类
}Kotlin中使用in 和out
package com.example.myapplication.kotlinlearn06class kt110 {
}// 小结当我们对整个类里边的泛型只能修改不能读取时可以声明为逆变
// 当我们对泛型只能读取不能给外界修改更新时可以声明为协变
class SetClassout T(item: T) { //声明式逆变泛型Java不能在声明处只能在使用处// 200个函数对T只能修改不能对外界读取val res itemfun get(): T {return res}}// TODO 110-Kotlin中使用in和out
fun main() {val list: ListInt //不可变val list2: MutableListInt //可变集合}
reified关键字 监测 泛型T的类型
package com.example.myapplication.kotlinlearn06class Object1inline fun reified T showTypeInfo(item: T) {if (Object1() is T) {println(aa)} else if (item is Object1) {}val list listOf(aa, bb)list.shuffled().first()//随机获取集合中的元素}class kt111 {
}//TODO reified 是真泛型类型的监测
fun main() {}Kotlin 的 扩展函数
package com.example.myapplication.kotlinlearn06class Object1inline fun reified T showTypeInfo(item: T) {if (Object1() is T) {println(aa)} else if (item is Object1) {}val list listOf(aa, bb)list.shuffled().first()//随机获取集合中的元素}class kt111 {
}//TODO reified 是真泛型类型的监测
fun main() {}超类上定义扩展函数
package com.example.myapplication.kotlinlearn06private fun Any.showPrintlnContent() println(当前的内容是$this) //将方法私有化this永远是调用者本身//TODO kt113-超类上定义扩展函数
fun main() {true.showPrintlnContent()
}Kotlin泛型的扩展函数
package com.example.myapplication.kotlinlearn06//TODO 114.Kotlin的泛型扩展函数
fun T T.showContentInfo() println(${if (this is String) 你的字符串长度是$length else 你不是字符串你的内容是$this})fun main() {许远志.showContentInfo()true.showContentInfo()
}Kotlin的标准函数与泛型扩展函数
package com.example.myapplication.kotlinlearn06//TODO 115.Kotlin的标准函数与泛型扩展函数fun main() {string.mLet {trueaa}
}private inline fun I, O I.mLet(lambda: (I) - O): O lambda(this)Kotlin的内置函数与扩展属性
package com.example.myapplication.kotlinlearn06class kt116//扩展属性
val String.myInfo: Stringget() 许远志fun String.showPrintln(): String {println(aaa)return this
}//TODO 116.Kotlin内置函数与扩展属性
fun main() {// run 和let会根据最后一行的返回值作为返回值// run 持有this let 持有it//TODO 扩展属性println(this.myInfo)333.showPrintln().myInfo}Kotlin可空类型扩展函数
package com.example.myapplication.kotlinlearn06class kt116//扩展属性
val String.myInfo: Stringget() 许远志fun String.showPrintln(): String {println(aaa)return this
}//TODO 116.Kotlin内置函数与扩展属性
fun main() {// run 和let会根据最后一行的返回值作为返回值// run 持有this let 持有it//TODO 扩展属性println(this.myInfo)333.showPrintln().myInfo}infix中缀表达式
package com.example.myapplication.kotlinlearn06//TODO 118.Kotlin的infix关键字
//自定义的中级表达式扩展函数一起使用
// infix 中缀表达式是简化我们的代码
private infix fun C1, C2 C1.go(c2: C2) {}fun main() {123.go(许远志)123 go 许远志
}导入扩展文件
package com.example.myapplication.kotlinlearn06
//导入扩展文件
import com.example.myapplication.kotlinlearn06.randomItemValue//TODO 119.Kotlin的定义扩展文件fun main() {val list: ListString listOf(张三, 李四, 王五)//第一种不使用扩展文件println(list.shuffled().first())println(list.randomItemValue())}package com.example.myapplication.kotlinlearn06fun E IterableE.randomItemValue() shuffled().first()重命名扩展函数
package com.example.myapplication.kotlinlearn06//导入扩展文件
import com.example.myapplication.kotlinlearn06.randomItemValue as p//TODO 119.Kotlin的定义扩展文件fun main() {val list: ListString listOf(张三, 李四, 王五)//第一种不使用扩展文件println(list.shuffled().first())println(list.p())}7. 手写内置函数
手写apply函数
package com.example.myapplication.kotlinlearn06class kt121 {}fun main() {许远志.mApply {aaa}.apply { }
}/*private 表示私有inline 因为我们的函数是高阶函数需要使用内联对lambda进行优化处理funINPUT 函数中声明一个泛型INPUT.mApply 表示所有的类型都能调用这个函数,INPUT.()代表对这个泛型进行了匿名函数扩展 ,函数扩展持有的thisthis持有的调用者本身Unit 永远返回调用者本身lambda(this) 永远都有this ,this可以省略*/
private inline fun INPUT INPUT.mApply(lambda: INPUT.() - Unit): INPUT {lambda()return this;
}DSL学习
package com.example.myapplication.kotlinlearn06import java.io.File//TODO 122.Kotlin的DSL学习
// TODO dsl学习 就是领域专用语言Domain Specified Language/DSL GradleJsonXML等inline fun File.applyFile(action: (String, String) - Unit): File {action(name, this.name)return this
}fun main() {}Kotlin的map变换函数
package com.example.myapplication.kotlinlearn06class kt123 {
}//TODO 123.Kotlin的map变换函数
fun main() {var list: MutableListString mutableListOf(张三, 李四, 王五)//原理及时吧匿名函数最后一个返回值加入到新的集合里面去var list2 list.map {//it 等于 每一个元素 ”张三 李四 王五it 是$it$it}.map {$ it的长度是${it.length}}println(list2)
}变换函数flatmap
package com.example.myapplication.kotlinlearn06class kt124 {
}//TODO 124.Kotlin的变换函数flatMap
fun main() {val list: ListString mutableListOf(张三, 李四, 王五)val list2 list.flatMap { //每次都会返回一个集合 ,把买一个集合加到新集合里listOf(aaa, bbb, ccc) //会做扁平化处理 把每个元素变成一个新的集合然后又加入到新的集合去}val list3 list.map {赵六}println(list2)println(list3)
}过滤函数filter
package com.example.myapplication.kotlinlearn06class kt125 {
}//TODO 125.过滤函数 filter
fun main() {val names listOf(张三, 李四, 王五)val result names.filter {it 张三 //如果为true 会加入到新的集合 如果为false 则过滤掉}names.filter {it.contains(张)}.map {println($it)}println(result) //新集合 把过滤后的元素加入新集合
}合并函数zip
package com.example.myapplication.kotlinlearn06class kt126 {
}//TODO 126.Kotlin的合并函数zip
fun main() {val names listOf(张三, 李四, 王五)val ages listOf(1, 2, 3)val zip: ListPairString, Int names.zip(ages)println(zip.toMap())println(zip)//遍历zip.forEach {//println(姓名是${it.first},年龄是${it.second})}//解构zip.toMap().forEach { (k, v) -println(k是$k,v是$v)}
}函数式编程响应式编程
package com.example.myapplication.kotlinlearn06class kt126 {
}//TODO 126.Kotlin的合并函数zip
fun main() {val names listOf(张三, 李四, 王五)val ages listOf(1, 2, 3)val zip: ListPairString, Int names.zip(ages)println(zip.toMap())println(zip)//遍历zip.forEach {//println(姓名是${it.first},年龄是${it.second})}//解构zip.toMap().forEach { (k, v) -println(k是$k,v是$v)}
}Kotlin的互操作性和可空性
package com.example.myapplication.kotlinlearn06//TODO 128.Kotlin的互操作性与可空性
fun main() {var name: String? a//接收Java的变量的时候要用string来接收Java的值name nullprintln(name?.length)
}7.1 Kotlin的单例模式
package com.example.myapplication.kotlinlearn06//TODO 单例模式
//1.饿汉式的实现 KT版本 先把实例实例化出来
object Singleton//2. 懒汉式实现
class Singleton2 private constructor() {companion object {private var instance: Singleton2? nullget() {if (field null) {field Singleton2()}return field}fun getInstance(): Singleton2? instance}
}// 3.线程安全版本
class Singleton3 private constructor() {companion object {private var instance: Singleton3? nullget() {if (field null) {field Singleton3()}return field}Synchronizedfun getInstance(): Singleton3? instance}
}//4. 双重校验锁版本
class Singleton4 private constructor() {companion object {val instance: Singleton4 by lazy(mode LazyThreadSafetyMode.SYNCHRONIZED) { Singleton4() }}
}
7.2 Kotlin的注解
JvmName
file:JvmName(Stu) //在编译时把类名改成自定义的名称
package com.example.myapplication.kotlinlearn06class kt130 {
}//TODO 130.注解jvmName
fun main() {println(hello world)
}JvmField注解
package com.example.myapplication.kotlinlearn06class kt131 {JvmField //把反编译后的Java代码修饰符变成publicval names listOf(张三, 李四, 王五)
}// TODO 131.注解JvmField
fun main() {}JvmStatic注解
package com.example.myapplication.kotlinlearn06class MyObject {companion object {JvmFieldval TARGET 张三JvmStatic //加上这个注解之后在Java里使用这个方法就可以直接用了fun showAction(name: String) println($name 要去 $TARGET 玩)}
}//TODO 133.注解JvmStatic与Kotlin的关系
fun main() {//KT 端println(MyObject.TARGET)MyObject.showAction(啦啦啦)
}7.3 手写RxJava
package com.example.myapplication.kotlinlearn06class kt134 {
}// TODO 134.手写RxJava操作符
// Lambda是以最后一行作为返回值
fun main() {create {333}.map {张三trueddd}.map {}
}class RxJavaCoreClassObjectT(val valueItem: T)inline fun INPUT, OUTPUT RxJavaCoreClassObjectINPUT.map(mapAction: INPUT.() - OUTPUT): RxJavaCoreClassObjectOUTPUT {val mapResult valueItem.mapAction()return RxJavaCoreClassObject(mapResult)
}//create 接收一个lambda表达式作为参数然后执行lambda的函数体然后等create参数调用
inline fun CREATE_OUTPUT create(createLambda: () - CREATE_OUTPUT): RxJavaCoreClassObjectCREATE_OUTPUT {val createResult: CREATE_OUTPUT createLambda()return RxJavaCoreClassObject(createResult)
}
