Kotlin基础6

Double转Int:

//精度损失
    println(8.956756.toInt())
    //四舍五入
    println(8.956756.roundToInt())
    //小数点后两位并四舍五入
    var s = "%.2f".format(8.956756)
    println(s)

标准库函数

apply：

apply函数可看作一个配置函数，你可以传入一个接收者，然后调用一系列函数来配置它以便使用，如果提供lambda给apply函数执行，它会返回配置好的接收者。
可以看到，调用一个个函数类配置接收者时，这是因为，在lambda表达式里，apply能让每个配函数都作用于接收者，这种行为有时又叫做相关作用域，因为lambda表达式里的所有函数调用都是针对接收者的，或者说，它们是针对接收者的隐式调用。

var file1 = File("D://111.txt")
    file1.setReadable(true)
    file1.setWritable(true)
    file1.setExecutable(false)

    var file2 = File("D://111.txt").apply {
        file1.setReadable(true)
        file1.setWritable(true)
        file1.setExecutable(false)
    }

let:

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

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

    val firstnum = listOf(3, 2, 1).first()
    val result1 = firstnum * firstnum       //9
}

fun formatgreeting(guestname:String ?):String{
    return guestname?.let {
        "Welcome, $it."
    }?:"Who are you?"
}

fun formatgreeting2(guestname:String ?):String{
    return if (guestname!=null){
        "Welcome, $guestname."
    }else{
        "Who are you?"
    }
}

run:(与let一样执行表达式的结果，同时还具备apply的隐式调用)

光看作用域行为，run和apply差不多，但与apply不同，run函数不返回接收者，run
返回的是lambda结果，也就是true或者false。

run也能用来执行函数引用

fun main() {
    var file = File("D://111.txt")
    var result = file.run {
        readText().contains("great")
    }
    println(result)     //Boolean类型

    var result2 = "The people's Republic of China.".run { ::isLong }
    println(result2)

    "The people's Republic of China."
        .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{
        "Please rename ."
    }
}

with：

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

fun main() {
    val result1 = "The people's Republic of China.".run {
        length >= 10
    }
    val result2 = with("The people's Republic of China."){
        length >= 10
    }
    
}

also：

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

fun main() {
    var filecontents:List<String>
    File("D://111.txt")
        .also {
            println(it.name)
        }.also {
            filecontents = it.readLines()
        }
    println(filecontents)
}

takeif:

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

fun main() {
    val result :String? = File( "D://111.txt")
        .takeIf { it.exists() && it.canRead() }
        ?.readText()
    println(result)
}

takeUnless:(负负为正)

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

   val result :String? = File( "D://111.txt")
        .takeUnless { it.isHidden }
        ?.readText()
    println(result)

集合

集合可以方便你处理一组数据，也可以作为值参传给函数，和我们学过的其他变量类型一样，List、Set和Map类型的变量也分为两类，只读和可变

List创建与元素获取：

getOrElse是一个安全索引取值函数，它需要两个参数，第一个是索引值，第二个是能提供默认值的lambda表达式，如果索引值不存在的话，可用来代替异常getOrNull是Kotlin提供的另一个安全索引取值函数，它返回null结果，而不是抛出异常。

fun main() {
    val list = listOf("Jason", "Jack", "Jacky")
//    println(list[3])  //空指针异常下标越界
    println(list.getOrElse(3) { "Unknown" })
    println(list.getOrNull(3)?: "Unknown")
}