Kotlin语言(可空性,安全调用,空合并操作符,异常,截取函数,分割函数,replace,比较,类型转换,遍历)

一、Kotlin语言的可空性特点

fun main() {
    //第一种情况，默认是不可空类型，不能随意给null
    var name : String = "Derry"
    
    //提示：不能使非空类型String的值
    //name = null
    println(name)

    //第二种情况，声明时指定为可空类型,加一个问号
    var name2: String ?
    name2 = null
    println(name2)
}

二、Kotlin语言的安全调用操作符

fun main() {
    var name: String? = "zhangsan"
    name = null
    // name.capitalize()  //capitalize方法用于将字符第一个字符变成大写字符    
    //上一行代码报错：原因是name是可空类型，可能是null，想要使用name，必须给出补救措施
    var r = name?capitalize() //name 是可空类型的，如果真的是null，？后面这一段代码不执行，就不会引起空指针异常
    println(r)  //null
}

三、在Kotlin中使用带let的安全调用

fun main() {
    var name: String? = null
    //name = "Derry"
    //let是内部提供的一个函数，可以把name拿进函数中用，函数里有一个it，这个it==name
    var r = name?.let {
        //it == name 本身
        //如果能够执行到这个函数里面，it一定不为null
        if (it.isBlank()) {  //如果name是空值 "" 没有内容
            "Default" //返回的
        } else {
            it //返回的
        }
    }
    println(r)
}

四、Kotlin语言中的非空断言操作符特点

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

    name = "derry"
    //补救措施，我们已经学习了？
    var r = name!!.capitalize() // !! 不管name是不是null，都执行，这个和java一样了
    println(r)

    //结论：如果百分百能够保证name是有值的，那么才能使用断言，否则有Java空指针异常的风险
}

五、Kotlin语法中对比使用if判断null值情况

fun main() {
    var name: String? = null
    name = "DDD"
    if(name != null) {  //if也算是补救措施 ,和Java一眼
        val r = name.capitalize()
        println(r)
    } else {
        println("name is null")
    }
}

六、Kotlin空合并操作符

fun main() {
    var info: String? = "李晓空"
    info = null
       
    //空合并操作符 XXX ?: "解释"
    //如果XXX等于null，就会执行?：后面的区域
    println(info ?: "原来你是null")

    
    //let函数 + 空合并操作符
    println(info?.let {"[$it]"} ?: "原来你是null")
    //这里如果不为null，执行let函数，否则，执行空合并操作符
}

七、Kotlin语法中异常处理与自定义异常特点

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

fun checkException(info: String) {
    info ?: throw CustomException()
}

class CustomException : IllegalArumentException("你的代码太不严谨了")

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

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

    //下面两个函数用于判断如果为null，会抛出一个异常
    //checkNotNull(value1)
    requireNotNull(value1)

    //判断是否是false，如果是，则会抛出一个异常
    require(value2)
}

九、Kotlin语言的substring（截取函数）

const val INFO = "Derry is Success Result"

fun main() {
    //indexOf，获取下标
    val indeOf = INFO.indexOf('i')
    //substring是一个截取函数
    println(INFO.substring(0,indexOf))
    println(INFO.substring(0 until indexOf))  //和上面实现效果一样，KT基本上用这种方式
}

十、Kotlin语言的split操作（分割函数）

fun main() {
    val jsonText = "Derry ,Leo ,Lance ,Alvin"
    //list 自动类型推断成list == List<String>
    //split函数是用于分割操作的
    val list = jsonText.split(",")  
    
    //直接输出list集合，不解构
    println("分割后的list里面的元素有：$list")
    
    //C++ 解构，KT也有解构
    val (v1,v2,v3,v4) = list
    println("解构四个只读变量的值是：$v1,$v2,$v3,$v4")
}

十二、Kotlin语言的replace完成加密解密操作

fun main() {
    val sourcePwd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    println("原始密码是：$sourcePwd")

    //加密操作:把字符替换成数字，打乱了，就属于加密了
    //replace是一个内置函数
    val newPwd : String = sourcePwd.replace(Regex("[AKMNO]")) {
        when(it.value) {    //it.value就是这里的每一个字符
            "A" -> "9"
            "K" -> "8"
            "M" -> "7"
            "N" -> "6"
            "O" -> "5"
            else -> it.value //啥事儿都不做，直接返回字符本身
        }
    }
    println("加密后的密码是：$newPwd")

    //解密操作
    val sourcePwdNew = newPwd.replace(Regex("[98765]")) {
        when(it.value) {    //it.value就是这里的每一个字符
            "9" -> "A"
            "8" -> "K"
            "7" -> "M"
            "6" -> "N"
            "5" -> "O"
            else -> it.value //啥事儿都不做，直接返回字符本身
        }
    }
    println("解密后的密码是：$sourcePwdNew")

}

十三、Kotlin语言的==与===比较操作
 1. == 值 内容的比较   （相当于Java的equals）
 2. === 引用的比较

fun main() {
    val name1 = "Derry"
    val name2 = "Derry"
    
    //值的比较
    println(name1.equals(name2)) //java
    println(name1 == name2) //KT
    
    //引用的比较
    //字符串常量池里有一个字符串Derry，name1和name2 都指向它，所以引用一样
    println(name1 === name2)  //true
    
    val name3 = "derry".capitalize() //将小写derry，修改成Derry
    println(name4 === name1)  // false
}  

十四、Kotlin语言的字符串遍历操作

fun main() {
    val str = "ABCDEFG"
    str.forEach { c -> //覆盖默认的it参数名，修改参数性为c
        //it == str的每一个字符
        // print("$it,")
        print("所有 字符是：$c")
    }
}

十五、Kotlin语言中数字类型的安全转换函数

fun main() {
    val number: Int = "666".toInt()
    println(number)
    
    //字符串里面放入了Double类型，无法转换成Int，会崩溃
    //val number2: Int = "666.6".toInt()
    //println(number2)

    //解决崩溃问题:如果转换成功，则转换Int，转换失败，则转换Null
    val number2: Int? = "666.6".toIntOrNull()
    println(number2 ?: "原来你是null")  //null，可以使用空合并字符

    //小结：以后字符串有整型相关的转换，尽量用toIntOrNull函数
}

十六、Kotlin语言中Double转Int与类型格式化

fun main() {
    println(65.2323.toInt())  //65 四舍五入
    println(65.34.roundToInt())  //65 四舍五入
    println(65.65.randToInt()) //66 四舍五入
    
    //结论：用roundToInt()函数，保证Double->Int,持有四舍五入的效果
    //r的类型：String
    val r = "%.3f".format(65.23567)
    println(r) //65.235
}