45.Kotlin语言的replace
46.Kotlin语言的==与===比较操作
47.Kotlin语言的字符串遍历操作
48.Kotlin语言中数字类型的安全转换函数
49.Kotlin语言中Double转Int与类型格式化
50.Kotlin语言的apply内置函数
51.Kotlin语言的let内置函数
52.Kotlin语言的run内置函数
53.Kotlin语言的with内置函数
54.Kotlin语言的also内置函数
55.Kotlin语言的takeIf内置函数
56.Kotlin语言的takeUnless内置函数

replace

内部函数
public inline fun CharSequence.replace(regex: Regex, replacement: String): String = regex.replace(this, replacement)

参数是正则表达式，返回表达式字符串

fun main(){
    val pwd = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    val result = pwd.replace(Regex("[AKMN]")){
        when(it.value){
            "A" -> "1"
            "K" -> "3"
            "M" -> "9"
            "N" -> "5"
            else -> it.value
        }

    }
    println(result)
}

foreach lambda

    pwd.forEach {
        print("$it >")
    }

安全类型转换toIntOrNull，以此类推

val num1 = "666".toIntOrNull()
    println(num1)
    val num2 = "666.66".toIntOrNull()
    println(num2)
    val num3 = "666.66".toIntOrNull()
    println(num3 ?: 0)

数字格式化

    val a = 63.45678
    val b = 64.87654
    val c = "64.87654"
    println(a.toInt())
    println(b.toInt())
    println(a.roundToInt())
    println(b.roundToInt())

    println(("%.3f").format(a))

apply

 val info = "Hello World！"

    println(info.length)
    println(info[info.length - 1])
    println(info.toLowerCase())

    //apply 始终返回本身
    val re = info.apply {
        println(this)
    }.apply {
        println("$length")
    }.apply {
        println("$this{[length - 1]}")
    }.apply {
        println(toLowerCase())
    }
  比如应用到File操作等

 apply 返回的始终是自己的引用this，可以链式调用，一般结合binding等共有属性判断是否为空等操作使用

let 最后一行就是他的返回值

val list = listOf(6, 5, 4, 3, 2, 1).let {
        it.first()
        true
    }
    println(list)

    println(method1(null))
    println(method2(null))

fun method1(param: String?) = if(param.isNullOrBlank()) "your param are empty" else "your param is ${param}"

fun method2(param: String?) = param?.let { "your param is $param?" } ?: "your param are empty"

使用场景是，判断是否为空等的造作，如果为null如何处理

let 我在实战中的一个用法，结合Spannable,查找回复@xxxx，高亮显示文本

 holder.dataBinding?.apply {
                tvCommentNikename.text = item.userInfo?.nick?.let {
                    "${it}: "
                } ?: ""


                val filter = Regex("[@][\\S]+\\s").find(item.content, 0)?.range
                val begin = filter?.first ?: 0
                val end = filter?.last ?: 0
                tvCommentContent.text = filter.let {
                    it?.let {
                        if(begin == end) {
                            item.content
                        } else {
                            val sb = SpannableString(item.content)
                            sb.setSpan(
                                ForegroundColorSpan(Color.parseColor("#44adfe")),
                                begin,
                                end,
                                Spannable.SPAN_INCLUSIVE_EXCLUSIVE
                            )
                            sb
                        }
                        

                    } ?: item.content
                } ?: item.content
            }

run , 持有的是自身引用this和apply，返回值如let最后一行的值决定run的返回值

str.run{
匿名函数
}

str.run(::具名函数)

 val str = "123456"
    val strResult = str
        //boolean
        .run(::isLong)
        //String
        .run(::showText)
        .run (::mapText)
//        .run(::println)

    println(strResult)//<字符串合格>
行·



fun isLong(str: String) = str.length > 5
fun showText(isLong: Boolean) = if (isLong) "字符串合格" else "不合格"
fun mapText(param: String) = "<${param}>"

with 和run基本一样，但是可以传入参数

 str = "David"

    with(str, ::println)

    with(with(with(with(str) {
        length
    }) {
        "your name length is:$this"
    }) {
        "[$this]"
    }) {
        println(this)
    }

    val r1 = with(str,::getStrLength)
    var r2 = with(r1,::getLenInfo)
    var r3 =with(r2,::getInfoMap)
    with(r3,::showStr)

also 类似apply，返回对象是 xxx.also. 前面xxx本身

"demo".also {
        println(it)
    }.also {
        println(it.toUpperCase())
    }

    val file = File("./test.txt")
    var sourceFile = file.also {
        it.setReadable(true)
        it.setWritable(true)
        println(file.readLines())
        // ... 其他很多事
    }.also {
        // ...
    }
    //sourceFile 没有任何影响

takeIf 需要和空操作一起使用

 val result1 = checkPermission("Root","123456")
    if(result1 != null) {
        println("欢迎@${result1}用户登陆拥有超级权限")
    } else {
        println("权限不够")
    }


fun checkPermission(name:String,pwd:String):String?{
    return name.takeIf { permissionSystem(name,pwd) }
}

fun permissionSystem(username:String,pwd:String):Boolean{
    return username == "Root" && pwd == "123456"
}

takeUnless

 val infoStr:String? = "1234"/*null*/
    val result3 = infoStr.takeUnless { infoStr.isNullOrBlank() }?:"没有初始化"
    println(result3)