一.字符串操作

1.substring

? ? ? ? ?字符串截取，substring函数支持IntRange类型(表示一个整数范围的类型)的参数，until创建的范围不包括上限值(包前不包后)。

const val  NAMES="jack,xiao,jason"
fun main() {
                                   //包前不保后
    val substring = NAMES.substring(0 until 3)
    println(substring)
}

2.split

? ? ? ? split函数分割后返回的是一个List集合，而List集合又支持解构语法，它允许你在一个表达式里，同时给多个变量赋值，解构常用来简化变量赋值。

const val  NAMES="jack,xiao,jason"
fun main() {
    //      通过解构语法，同时赋值多个变量
    val  (origin,dest,proxy) = NAMES.split(",")
    println("$origin   $dest    $proxy")
}

3.replace

? ? ? ? ?replace函数替换字符串，我们可以和when函数配合使用

fun main() {
    //替换
    val str1 = "United States of America"
    //一个参数，Regex函数是一个正则表达式(区分大小写)，用来觉定替换那些字符
    //第二个参数是匿名函数，我们用了when函数确定如何替换这些字符
    val str2 = str1.replace(Regex("[usoa]")) {

        when (it.value) {
            "a" -> "6"
            "s" -> "8"
            "o" -> "2"
            "a" -> "9"
            else -> it.value
        }
    }

    println("$str1 \n")
    println(str2)
}

4.字符串比较

? ? ? ? ?在kotlin中，用==检查两个字符串中的字符是否相同，用===检查两个字符串变量的对

??象地址是否相同。

fun main() {
    //== 比较内容   ===比较内存地址  //当比较两个指值为一常量的话内存地址还是一样的，变量则不同
    val str3 ="XiaoHua"
    //                    拷贝
    val  str4=str3.capitalize()
    println("$str3   $str4")
    println(str3==str4)
    println(str4===str3)
}

5.forEach

fun main() {
    //循环字符串
    val str5="United States of America"
    str5.forEach {
        println("$it *")
    }
}

二.数字类型转换

1.安全转换函数

? ? ? ? ?Kotlin提供了toDoubleOrNull和toIntNull这样的安全转换函数，如果数值不能正确转换，与其触发异常不如返回null值

fun main() {
    //没转成功会返回空
    val  number:Int? ="8.89".toIntOrNull()
 //没转成会直接报错
  //  val  number1:Int? ="8.89".toInt()
    println(number)
    println(number1)
}

2.Double转In

fun main() {
    //小数点后面省略
     println(8.956756.toInt())
    //四舍五入
    println(8.956756.roundToInt())
}

3.Double类型格式化

? ? ? ? 格式化字符串是一组特殊字符，他将决定如何格式化数据

fun main() {
    //保留小数点后两位，并转为字符串
    val format = "%.2f".format(8.956756)
    println(format)
}

三.标准库函数

? ? ? ??

1.apply

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

fun main() {
    //未使用apply函数
    val file = File("E://i have a dream_copy.text")
    file.setReadable(true)
    file.setWritable(true)
    file.setExecutable(false)
    //使用apply函数
    //可以隐式调用在本对象里的作用函数，并返回经过配置的对象
    val apply = File("E://i have a dream_copy.text").apply {
        setReadable(true)
        setWritable(true)
        setExecutable(false)
    }
}

????????如上所述，调用一个个函数类配置接收者时，变量名就省略了，这是因为，在lambda表达式里，apply能让每个配置函数都作用于接收者，这种行为又叫做相关作用域，因为lambda表达式里的所有函数调用都是针对接收者的，或者说他们接收者的隐式调用。

2.let

? ? ? ? let函数能使每个变量作用于其lambda表达式里，让it关键字能引用它。let与apply比较，

let会把接收者传给lambda，而apply什么都不传，匿名函数执行完，apply会返回当前接收者，

而let会返回lambda的最后一行

fun main() {
    //let 会在最后一行返回经过函数里面运算的值  apply只能返回当前调用对象和作隐式调用
    //使用let下发
    val result = listOf(3, 2, 1).first().let {
        it * it
    }

    print(result)
    //不使用let写法
     val first = listOf(3, 2, 1).first()
     print(first*first)
   
}

3.run

? ? ? ? run和apply一样能在作用域里隐式调用，但又与apply不同，run函数返回的时lambda结果，同时run也能执行函数引用

fun main() {

    //run  和apply类似也可以隐式调用  但会返回lambda结果

    val run1 = "The people' s Republic of China".run {
        "$length ,$this"
    }
    println(run1)
                    //run也能用来执行函数引用
                    // 双::   和引用是一个作用 比如this 和new出来的对象
    val run = "The people' s Republic of China".run(::isLong).run (::println)

}

fun isLong(name :String) =name.length>=10

4.With

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

fun main() {
    //with和run 一样就是参数位置的区别
    val run = "The people' s Republic of China".run {
      length >= 10
    }
    val with = with("The people' s Republic of China") {
        length >= 10
    }
}

5.also

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

fun main() {
    var fileContents:List<String>
    //also 和let 类似但会返回原对象不是lambda
    val file = File("C://data.txt")
        .also {
            print(it.name)
        }.also {
             fileContents = it.readLines()
        }
    
    println(fileContents)
}

6.takeIf

? ? ? ? 和其他标准函数有点不一样，takeIf函数需要判断lambda中提供的条件表达式，给出true，从takeIf函数返回接收这对象，如果是false，则返回null。结果需要判断某个条件是否满足，再决定是否可以赋值变量或执行某项任务。

fun main() {
    //takeIf  最后一行放一个吧boole类型的lambda  为true 会返回原对象  为false 会返回null  类似 if  else
    val readText = File("")
        .takeIf {
            it.exists() && it.canRead()
        }?.readText()
        println(readText)
}

7.takeUnless

? ? ? ? takelf辅助函数takeUnless，只有判断你给定的条件结果是false时，takeUnIsee才会返回原始接收者对象.

fun main() {
    //takeUnless与takeIf 作用一样但相反    为false 会返回原对象  为true 会返回null
    val readTextUnless = File("")
        .takeUnless {
            it.exists() && it.canRead()
        }?.readText()
    println(readTextUnless)
}