1、Kotlin非空断言操作符

kotlin在空判断的补救措施？if !!

fun main() {
    var name: String? = null

    //name.capitalize()//name可为空，需要自己补救

    //补救措施 ？ !! ,其中 !!是断言不为null,无法保证使用?
    val r = name!!.capitalize() // 不管name是不是null都执行。 和Java一样
    println(r)

    //if的补救措施和java一样
    if (name != null) {
        val r = name!!.capitalize()
    } else {
        println("name is null")
    }

}

2、Kotlin 空合并操作符

//TODO Kotlin 空合并操作符

fun main() {
    var info: String? = "李小龙"

    info = null

    // xxx？:为null 会执行后面得
    println(info ?: "原来你是空的")

    //let + 空合并操作符

    //it代表info本身
    println(info?.let { "[$it]" } ?: "原来你是空")


}

3、Kotlin中异常处理与自定义异常特点

fun main() {
    try {
        var info: String? = null
        checkException()
        println(info!!.length)
    } catch (e: java.lang.Exception) {
        println("e:$e")
    }

}

fun checkException(info: String?) {
    TODO("Not yet implemented")
    info ?: throw CustomException()
}

class CustomException : IllegalArgumentException("你的代码不严谨")

展示了自定义异常，与平时的异常处理和打印

4、Kotlin语言的先决条件函数

展示了字符串为空时的合理判断

//TODO Kotlin 先决条件函数

fun main() {
    var value1: String? = null
    var value2: Boolean = false

    //检测String的空和Boolean的空 可用先决条件函数
//    checkNotNull(value1)

    requireNotNull(value1)

    require(value2)
}

5、Kotlin subString截取字符串

建议与until配合使用,截取从0到indexof

//TODO Kotlin substring

const val INFO = "zhangsan is success"

fun main() {
    val indexof = INFO.indexOf('i')
    println(INFO.substring(0, indexof))
    //建议使用下面这种方式
    println(INFO.substring(0 until indexof))
}

6、Kotlin 字符串遍历 forEach

//TODO Kotlin 字符串遍历操作

//ABCDEFGHIJKLMNOPQRSTUVWXYZ
fun main() {
    val str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    str.forEach {
        // it等于 str的每一个字符 ABCD。。。

        print("所有的字符是: $it ")
    }

}

7、Kotlin 中数字类型安全转换

//TODO Kotlin 数字类型安全转换函数

fun main() {


    val number: Int = "666".toInt()

    println(number)

    //字符串里面放double无法转化为int,会崩溃
//    val number2:Int = "666.6".toInt()
//    println(number2)

    //解决上面崩溃问题 成功返回，不成功，返回null
    val number2: Int? = "666.6".toIntOrNull()
    println(number2)

    val number3: Int? = "888".toIntOrNull()
    println(number3)


    val number4: Int? = "888.8".toIntOrNull()
    println(number4 ?: "原来你是null")

    //字符串有Int相关转换，尽量用toIntOrNull

}

8、Kotlin apply 内置函数

import java.io.File

//TODO Kotlin 数字类型安全转换函数

fun main() {

    val info = "zhangsan ni hao"
    //普通方式

    println("info字符串长度是: ${info.length}")

    println("info最后一个字符是:${info[info.length-1]}")
    println("info 全部转成小写:${info.toLowerCase()}")


    //apply 内置函数
    //特点:apply始终返回info本身
    val infoNew:String = info.apply {
        // 一般大部分情况下，匿名函数都会持有一个it,但是apply函数不会持有it，持有当前this,this == info
        println(this)

        //this可以省略
        println("apply长度:${length}")
        println("apply最后一个字符是:${this[length-1]}")
        println("apply全部转化为小写:${toLowerCase()}")
    }
    println("apply的返回值:$infoNew")

    println()

    //使用apply函数写法规则
    info.apply {
        //apply返回info本身，可以链式调用
        println("info的长度:$length")
    }.apply {
        println("apply最后一个字符是:${this[length-1]}")
    }.apply {
        println("apply全部转化为小写:${toLowerCase()}")
    }

    //普通写法
    val file = File("D:\a.txt")
    file.setExecutable(true)
    file.setReadable(true)
    println(file.readLines())

    //apply里持有的this就是file本身
    file.apply {
        setExecutable(true)
    }.apply {
        setReadable(true)
    }.apply {
        println(file.readLines())
    }

}

apply总结:

1、apply函数返回类型，都是用于info本身

2、apply函数 ，匿名函数持有的是this == info本身

3、apply函数匿名函数的参数是this

9、Kotlin let内置函数

展示了匿名函数.run和具名函数.run的调用

//TODO Kotlin let内置函数

fun main() {
    //普通方式，对集合第一个元素相加
    val list: List<Int> = listOf(6, 5, 2, 3, 5, 7)
    val value1 = list.first() //第一个元素
    val result1 = value1 + value1

    println(result1)

    //let方式，对集合第一个元素相加,let返回的是匿名函数最后一行,apply返回info本身
    //let 函数里面持有的是it, it代表的是参数 此处it == list本身
    val result2 = listOf(6, 5, 2, 3, 5, 7).let {
        //it == list
        it.first() + it.first()
    }
    println(result2)


    //普通方式对空值判断,对值判null,并返回
    println(getMethod1(null))

    //let+空合并操作符
    println(getMethod3(null))
}

fun getMethod1(value: String?): String {
    return if (value == null) "你传递的内容是null,你在搞什么飞机" else "欢迎回来${value} 非常欢迎"

}

//普通方式简化版本
fun getMehod2(value: String?) = if (value == null) "你传递的内容是null,你在搞什么飞机" else "欢迎回来${value} 非常欢迎"

//let方式 对值判断null,并返回
fun getMethod3(value: String?): String {
    return value?.let {
        "欢迎回来:${it} 非常欢迎"
    } ?: "你传递的内容是null,你在搞什么飞机"
}

//let方式简化版本
fun getMethod4(value: String?) = value?.let {
    "欢迎回来:${it} 非常欢迎"
} ?: "你传递的内容是null,你在搞什么飞机"

let总结

1、let函数的匿名函数参数为it

2、let函数返回类型 是匿名函数的最后一行

3、let函数里it相当于集合，参数本身

10、Kotlin run内置函数

//TODO Kotlin run内置函数

fun main() {
    val str = "zhangsan is Ok"
    //1、run函数返回类型是根据最后一行的变化变化
    //2、run 函数的匿名函数 this == str本身，谁点出run，持有谁，与apply 一样
    val r1: Float = str.run {
        //this == str本身
        true
        45122.3f

    }

    println(r1)

    //下面实现具名函数配合run函数

    //这个是匿名函数配合run
    str.run {

    }

    //这个属于具名函数配合run
    str.run { }

    //这个是属于具名函数 ,具名函数.run()执行
    val r2 = str.run(::isLong)
        .run(::showText)
//       .run {
//           //this == String,this == 前面run的返回值
//       }
        .run(::mapText)
        .run(::println)//系统的具名函数打印
    println(r2)

    //匿名函数调用.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 mapText(getShow: String) = "[$getShow]"

run 总结

1、匿名函数参数是this 2、this == str本身，与apply一致，谁调用.run，this就是谁 3、run函数返回类型是根据最后一行的变化变化

11、Kotlin with函数

with和run基本一样，使用不同 with(str),其他功能一样

//TODO Kotlin with内置函数

fun main() {
    val str = "zhangsan is Ok"

    //具名函数
    with(str, ::println)
    var len = with(str, ::getStrLen)
    var r2 = with(len, ::getLenInfo)
    var r3 = with(r2, ::getInfoMap)
    with(r3, ::show)

    println(len)

    //匿名操作
    with(with(with(with(str) {
        len
    }) {
        "你的字符串长度是:$this"
    }) {
        "$this"
    }) {
        println(this)
    }

}

fun getStrLen(str: String) = str.length

fun getLenInfo(len: Int) = "你的字符串长度是:$len"

fun getInfoMap(info: String) = "[$info]"

fun show(content: String) = println(content)

with 总结

1、匿名函数参数是this 2、this == str本身，与apply一致，谁调用.run，this就是谁 3、run函数返回类型是根据最后一行的变化变化

12、Kotlin 中also函数

import java.io.File

//TODO Kotlin also函数

fun main() {

    //also
    //1、与apply 一样，谁.also,返回谁
    //2、与let一样 匿名函数it持有的是str本身
    val str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    val r: String = str.also {
        true
        45453.4f
        424
        'C'

    }
    val r2: Int = 123.also {
        true
        4535.4f
        4125
        'D'
    }
    println(r)

    println(r2)

    str.also {
        println("str原始数据:$str")
    }.also {
        println("str转化为大写效果:${it.toLowerCase()}")
    }.also {
        println("结束了")
    }

    val file = File("D:\a.txt")
    //匿名函数里做的事情和sourceFile无关，返回的是file本身
    val sourceFile = file.also {
        file.setReadable(true)
        file.setWritable(true)
        //...
    }.also {

        //...
    }.also {

        //...
    }

    //sourceFile没有任何影响


}

also函数总结

1、匿名函数的参数是it 2、与apply 一样，谁.also,返回谁 3、与let一样 匿名函数it持有的是str本身

13、Kotlin takeif 内置函数

一般大部分情况下，都是takeif + 空合并操作符

name.takeIf { permissionSystem(name, pwd) } ?: "你的权限不够"

//TODO Kotlin takeif函数

fun main() {

    val result = checkPermission("test", "123")
    println(result)

    println(checkPermission2("Root", "!@#$"))

    //一般大部分清空下，都是takeif + 空合并操作符
}

//前端

public fun checkPermission(name: String, pwd: String): String? {
    //name.takeif{true ,false} true返回name本身,false 返回null

    return name.takeIf { permissionSystem(name, pwd) }
}

public fun checkPermission2(name: String, pwd: String): String? {
    //name.takeif{true ,false} true返回name本身,false 返回null
    return name.takeIf { permissionSystem(name, pwd) } ?: "你的权限不够"
}

//权限系统
private fun permissionSystem(username: String, userpwd: String): Boolean {
    return if (username == "Root" && userpwd == "!@#$") true else false

}

14、Kotlin takeunless 函数

一般清空下takeunless+it.isNullOrBlank()一起使用，判断是否有初始化

class Manager {
    private var infoValue: String? = null
    fun getInfoValue(): String? = infoValue
    fun setInfoValue(infoValue: String?) {
        this.infoValue = infoValue
    }
}


fun main() {
    val manager = Manager()
    //一般清空下takeunless+it.isNullOrBlank()一起使用，判断是否有初始化
    val r = manager.getInfoValue().takeUnless { it.isNullOrBlank() } ?: "未经过任何初始化"
    println(r)
}

takeif 与takeenless比较

1、takeif和takeUnless相反

2、name.takeif{true/false} true:返回name本身,false返回null

3、name.takeunless{true/false} true:返回null,false返回name

4、为什么有takeunless出现？

用于判断是否初始化场景，与空合并操作符一起使用