字符串操作

1.substring

• 截取字符串
• until：左闭右开

const val NAME = "Jimmy's friend"
fun main() {
    val index = NAME.indexOf(''')
    val str = NAME.substring(0 until index)
    println(str)
}

2.split

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

const val NAMES = "jack,jacky,jason"
fun main() {
    val data = NAMES.split(',')
    val (origin, dest, proxy) = NAMES.split(',')
    println("$origin $dest $proxy")
}

3.replace

• 字符串替换

fun main() {
    val str1 = "The people's Republic of China"
    val str2 = str1.replace(Regex("[aeiou]")) {
        when (it.value) {
            "a" -> "1"
            "b" -> "2"
            "i" -> "3"
            "o" -> "4"
            "u" -> "6"
            else -> it.value
        }
    }
    println(str2)
}

4.字符串比较

• ==检查两个字符串的字符是否匹配
• ===检查两个变量是否指向内存堆上同一对象
• java字符串常量池,java字符串是不可变的，值变化是因为重新开辟了一个内存空间存储了新的字符串，而地址指向了新字符串的地址

fun main() {
    val str1 = "Hello"
    val str2 = "hello".capitalize()
    println(str1 == str2)
    println(str1 === str2)
}

结果：

true
false

5.字符串遍历-forEach

fun main() {
    val str1 = "Hello world"
    str1.forEach { print("$it *") }
}

数字类型

类型种类与范围与Java基本一致

1.安全转换函数

fun main() {
//    val number: Int = "8.98".toInt()
    val number: Int? = "8.98".toIntOrNull()
}

2.Double转Int

• toInt()直接取整数部分
• roundToInt()四舍五入

3.Double格式化

fun main() {
    val str = "%.2f".format(8.912312)
    println(str)
}

结果：8.91

标准库函数

1.apply

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

import java.io.File

fun main() {
    //配置一个File实例
    val file1 = File("E:/I have a dream_copy.txt")
    file1.setReadable(true)
    file1.setWritable(true)
    file1.setExecutable(true)
    //使用apply
    val file2 = File("E:/I have a dream_copy.txt").apply {
        setReadable(true)
        setWritable(true)
        setExecutable(true)
    }
}

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

2.let

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

fun main() {
    val result = listOf(1, 2, 3).first().let {
        it * it
    }
    println(result)
}

3.run

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

import java.io.File

fun main() {
    val file = File("E://test.txt")
    val result = file.run {
        readText().contains("great")
    }
    println(result)
}

fun main() {
    val result = "We are so happy".run { ::isLong }
    println(result)
}

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

• 链式调用时体现优势

fun main() {
    val result = "We are so happy".run(::isLong)
        .run(::showMessage)
        .run(::println)
}

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

fun showMessage(isLong: Boolean): String {
    return if (isLong) {
        "Name is too long"
    } else {
        "Name is too short"
    }
}

4.with

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

5.also（重要）

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

6.takeIf

• 和其他标准函数有点不一样，takeIf函数需要判断lambda中提供的条件表达式，给出true或false结果，如果判断结果是true，从takeIf函数返回接收者对象，如果false返回null。如果需要判断某个条件是否满足，再决定是否可以赋值变量或执行某项任务，takeIf就非常有用，概念上讲，takeIf函数类似于if语句，但它的优势是可以直接在对象实力上调用，避免了临时变量赋值的麻烦。

7.takeUnless

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