• kotlin的可空性
  1.在java中我们司空见惯的空指针异常，带给我们很多麻烦。kotlin改良后，更多的把运行时可能会出现的null问题，以编译时错误的方式，提前在编译期强迫我们重视起来，而不是等到运行时报错，防范于未然，提高了我们程序的健壮性。
  对于null值问题，除非有规定，否则不可以为null值，这样一来，运行时崩溃从根源上得到解决。

//声明可空
    var name :String?= "jinzong"
    name = null
    //声明可空，如果是空就不会执行capitalize方法；此方法是将字符串第一个首字母大写
    var capitalize = name?.capitalize()
    println(capitalize)

• 使用带let的安全调用

 //使用带let的安全调用，let是一个标准函数
    var str:String? = "butterfly"
    str = null
    //let函数意思是如果不为空才会去执行let函数中的逻辑
    //let函数其实就是匿名函数，lambda表达式，返回最后一行执行结果
    str = str?.let {
        //字符串不是""
        if(it.isNotBlank()){
            it.capitalize()
        }else{
            "butterfly"
        }
    }
    println(str)

• 非空断言操作符

//非空断言操作符
    //如果真的为空希望可以抛出异常
    str = "aaa"
    println(str!!.capitalize())

• 空合并操作符
  ?:操作符的意思是，如果左边的求值结果是null，就是用右边的结果值，空合并操作符也可以和let函数一起使用来代替if/else语句

//空合并操作符,经常会与let函数相结合使用
    //类似与java的三元运算符，如果?:左边的值是null，那就使用右边的值
    str = "guo"
    println(str?:"jack")
    println(str?.let { it.capitalize() } ?: "butterfly")

• 异常处理与自定义异常

    var num :Int ? = null
    try {
        checkOperation(num)
        num !!.toBigDecimal()
    }catch (e : Exception){
        println(e)
    }

fun checkOperation (num :Int?){
    //空合并操作符
//    num ?: throw stydu04.MyException()
    //这里可以使用kotlin提供的先决条件函数。kotlin提供了一些便利函数，使用这些内置函数，你可以抛出带自定义信息的异常，这些遍历函数叫做先决条件函数。
    //你可以用它定义先决条件，条件必须满足，目标代码才能执行
    checkNotNull(num,{"num是空，捕获到了异常"})
}

//自定义异常
class MyException : IllegalArgumentException("操作不当")

• substring
  字符串截取，substring函数支持IntRange类型（表示一个整数范围的类型）的参数，until创建的范围不包括上限值

//substiing方法
    var NAME = "Jimmy's Friend"
    val indexOf = NAME.indexOf('\'')
//    val substring = NAME.substring(0, indexOf)
    //这行代码和上面一行是一个意思
    val substring = NAME.substring(0 until indexOf)
    println(substring)

• split
  split函数返回的是List集合数据，List集合又支持解构语法特性，它允许你在一个表达式里给多个变量赋值，解构常用来简化变量的赋值

//split
    val NAMES = "jack,jacky,jason"
//    val split = NAME.split(',')
    val (a,b,c) = NAMES.split(',')
    println("$a $b $c")

• replace

//replace
    var str1 = "The People's Republic of China"
    val replace = str1.replace(Regex("[aeiou]")) {
        when (it.value) {
            "a" -> "8"
            "e" -> "2"
            "i" -> "4"
            "o" -> "0"
            "u" -> "8"
            else -> "9"
        }
    }
    println(str1)
    println(replace)

• 字符串比较 ，== 与 ===区别
  在kotlin中，用==检查两个字符串中的字符是否匹配，用===检查两个变量是否指向内存堆上同一对象，而在java中==做引用比较，做解构比较时用equals方法。

//字符串比较
    val s1 = "guowei"
    val s2 = "guowei"

    println(s1 == s2)  // 比较的是两个字符串的内容，true
    println(s1 === s2)  // 比较的是两个字符串的引用，true.
    //这里涉及到常量池，内存开辟一片字符串的常量池，字符串是不会被修改的，所以s1和s2指向的是同一个对象

val s3 = "Jinzong"
    val s4 = "jinzong".capitalize()
    println(s3 == s4) //内容相同，true
    println(s3 === s4) //s4相当于在内存中新创建了一个字符串，false

• 字符串遍历

//字符串遍历
    "hellow world".forEach {
        print("$it-")
    }

• 数字类型的安全转换函数
  kotlin提供了toDoubleOrNull和toIntOrNull这样的安全转换函数，如果数值不能正确转换，与其触发异常不如干脆返回null值

    //安全转换函数
//    val number1 = "1.56".toInt() // 此处会抛异常

    //如果数值不能正确转换，与其触发异常不如干脆返回null值
    val number2 = "1.56".toIntOrNull()
    println(number2)

    //double转int
    println(5.986.toInt())//返回5
    println(5.986.roundToInt())//返回6,这里是四舍五入

    //格式化字符串
    val format = "%.2f".format(5.6976)//格式化成两位小数，此处返回值是string
    println(format)

• 标准库函数apply
  apply函数可以看作一个配置函数，可以传入一个接收者，然后调用一系列函数来配置它以便使用，如果提供lambda给apply函数执行，它会返回配置好的接收者。

val file1 = File("E://i have a dream.txt")
    file1.setReadable(true)
    file1.setWritable(true)
    file1.setExecutable(false)

    //上面这段代码可以改为apply的标准函数
    var file2 = File("E://i have a dream.txt").apply {
        setReadable(true)
        setWritable(true)
        setExecutable(false)
    }

• 标准库函数let
  let函数能使某个变量作用于其lambda表达式里，让it关键字能引用它。let与apply比较，let会把接收者传给lambda，而apply什么都不传，匿名函数执行完，apply会返回当前接收者，而let会返回lambda的最后一行。

//let函数
    //获取一个集合的第一个元素的平方,let表达式接收的是前面的调用者，返回的最后一行执行结果
    val result = listOf(1, 2, 3).first().let {
        it * it
    }
    println(result)

//let表达式结合非空运算符
fun letTest (name:String?) :String{
    return name?.let {
        "welcome $name"
    } ?: "what's your name?"
}

在main中调用    println(letTest(null))

• 标准库函数run
  光看作用域行为，run和apply差不多，但与apply不同，run函数不返回接收者，run函数返回的是lambda结果

//run函数。与apply有点像，但与apply不同的是，run函数不返回接收者，返回的是lambda结果
    val file = File("E://kotlin.txt")
    val run = file.run {
        readText().contains("great2")
    }
    println(run)

run函数适用于多链式调用

//run函数的测试
fun isTooLong (name :String) = name.length >= 10

//run函数的测试
fun showMessage (isLong : Boolean):String {
    return if(isLong){
        "Name is Too Long,please rename"
    }else{
        "your name is great"
    }
}

在main函数中调用
//run函数适用与多链式调用
    "jfkdsajklfsjdlkfjjafdjskfd;"
        .run(::isTooLong)
        .run(::showMessage)
        .run(::println)

• 标准库函数with
  with函数式run的变体，他们的功能行为是一样的，但with的调用方式不同，调用with时需要值参作为其第一个参数传入。

//with函数是run函数的变体，功能行为是一样的，但with的调用方式不同，调用with时需要值参作为其第一个参数传入
    val result2 = with("fjaskdjflsdjfasjdfjlsja") {
        length >= 10
    }
    println("======= $result2")

• 标准库函数also
  also函数和let函数相似，和let一样，also也是把接收者作为值参传给lambda，但有一点不同：also返回接收者对象，而let返回lambda结果。因为这个差异，also尤其适合针对同一原始对象，利用副作用做事，既然also返回的时接收者对象，就可以基于原始接收者对象执行额外的链式调用。

//also函数和let函数功能相似，和let一样，also也是把接收者作为值参传给lambda，但不同的是，also返回的还是接受者
    //let返回的是lambda结果
    val fileContents:List<String> // 声明一个集合变量
    File("E://kotlin.txt")
        .also {
            //接收者是file，所以这个it代表着file对象
            println(it.name)
        }.also {
            //因为上一个also的返回者也是接收者，所以上一个aslo的返回者是file对象，所以这里还能使用it对象
            fileContents = it.readLines() //给集合赋值
        }
    println(fileContents)

• 标准库函数takeIf
  takeIf函数判断lambda中提供的条件表达式，如果判断结果是true，盲从takeIf函数返回接收者对象，如果是false，则返回null。和if语句是一样的，但是优势是可以直接在对象实例上调用，避免了临时变量赋值的麻烦。

//takeif语句，类似于if语句，但是好处是对象可以直接调用
    val result3 = File("E://kotlin.txt")
        .takeIf { it.exists() && it.canRead() }
        ?.readText()
    println(result3)

• 标准库函数takeUnless
  takeIf辅助函数takeUnless，只有判断给的条件结果是false，才会返回原始接收者对象