Kotlin基础知识3

空合并操作符

fun main(){
   var info:String?="Brett";
   println(info ?: "null")//如果info为null，就会执行?:后面的语句
}

kotlin的先决条件函数

fun main(){
   var value:String? = null
   var value2: Boolean = false
    // checkNotNull(value) // value为null会抛异常  java.lang.IllegalStateException: Required value was null.
    // requireNotNull(value) // value为null会抛异常 java.lang.IllegalArgumentException: Required value was null.
    require(value2) // value2为false，抛异常 java.lang.IllegalArgumentException: Failed requirement.
}

substring函数

fun main() {
    val indexOf = INFO.indexOf('i')
    println(INFO.substring(0, indexOf))
    println(INFO.substring(0 until indexOf)) // KT基本上用此方式： 0 until indexOf
}

split函数

fun main() {
    val jsonText = "aaa,bbb,ccc,ddd"
    // list 自动类型推断成 list == List<String>
    val list = jsonText.split(",")

    // 直接输出 list 集合，不解构
    println("分割后的list里面的元素有:$list")

    // C++ 解构  Kt也有解构
    val (v1, v2, v3, v4) = list
    println("解构四个只读变量的值是:v1:$v1, v2:$v2, v3:$v3, v4:$v4")
    val(_,v1,v2,v3) = list //用_内部可以不接收赋值，节约性能
}

字符串遍历

fun main() {
    val str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    str.forEach {  c -> // 覆盖默认的it参数名，修改参数名为 c
        // it == str的每一个字符 A B C D ...
        // print("所有的字符是:$it  ")
        print("所有的字符是:$c  ")
    }
}

比较操作

fun main() {
    // == 值 内容的比较  相当于Java的equals
    // === 引用的比较

    val name1 : String = "Derry"
    val name2 : String = "Derry"
    val name3 = "ww"

    // 小结：name1.equals(name2)  等价于 name1 == name2  都是属于 值 内容的比较
    println(name1.equals(name2)) // java true
    println(name1 == name2) // kt true

    // 引用的比较
    println(name1 === name2) // true
    println(name1 === name3) // false

    // 引用的比较 难度高一点点
    val name4 = "derry".capitalize() // 修改成"Derry"
    println(name4 === name1)
}

数字类型的安全转换函数

fun main(){
  val number = "999".toInt()
  println(number)
  val number2 = "999.9".toInt()//会奔溃
  //解决奔溃
  val number3 = "999.9".toIntOrNull()
  println(number3)
}

Int与Double类型转换

fun main(){
  println(12.3.toInt())//直接舍掉小数，不会四舍五入
  println(12.9.roundToInt())//会四舍五入
  val r:String = "%.3f".format(12.323)
  print(r)
}

replace函数

fun main(args: Array<String>) {
 
    var str = "Kotlin Tutorial - Replace String - Programs"
    val oldValue = "PROGRAMS"
    val newValue = "Examples"
 
    val output = str.replace(oldValue, newValue, ignoreCase = true)
 
    print(output)
}

apply函数

fun main() {
    val info = "Derry You Hao"

    // 普通的方式
    println("info字符串的长度是:${info.length}")
    println("info最后一个字符是:${info[info.length -1]}")
    println("info全部转成小写是:${info.toLowerCase()}")

    println()

    // apply内置函数的方式
    // info.apply特点：apply函数始终是返回 info本身 String类型
    val infoNew : String = info.apply {
        // 一般大部分情况下，匿名函数，都会持有一个it，但是apply函数不会持有it，却会持有当前this == info本身
        println("apply匿名函数里面打印的:$this")

        println("info字符串的长度是:${length}")
        println("info最后一个字符是:${this[length -1]}")
        println("info全部转成小写是:${toLowerCase()}")
    }
    println("apply返回的值:$infoNew")

    println()

    // 真正使用apply函数的写法规则如下：
    // info.apply特点：apply函数始终是返回 “info本身”，所以可以链式调用
    info.apply {
        println("长度是:$length")
    }.apply {
        println("最后一个字符是:${this[length -1]}")
        true
        true
        true
    }.apply {
        println("全部转成小写是:${toLowerCase()}")
    }

    println()

    // 普通写法
    val file = File("D:\\a.txt")
    file.setExecutable(true)
    file.setReadable(true)
    println(file.readLines())

    println()

    // apply写法
    // 匿名函数里面 持有的this == file本身
    /*val fileNew: File =*/ file.apply {
        setExecutable(true)
    }.apply {
        setReadable(true)
    }.apply {
        println(file.readLines())
    }
}

let函数

匿名函数最后一行作为返回值。

fun main(){
  var name:String? = null

  //name是可空类型，如果为null，?后面这一段代码不执行
  val r = name?.let{
     // let函数有一个内置的it参数就是name本身
     if(it.isBlank()){
        "Default"
     }else{
        it
     }
  }
}

also函数

fun main(){
   val str= "brett"
  // 真正使用also函数的写法规则如下：
    // str.also特点：also函数始终是返回 “str本身”，所以可以链式调用
    str.also {
        println("str的原始数据是:$it")
    }.also {
        println("str转换小写的效果是:${it.toLowerCase()}")
    }.also {
        println("结束了")
    }
}

with函数

fun main() {
    val str = "brett"

    // 具名操作
    /*with(str) {
        this == str本身
    }*/
    val r1 = with(str, ::getStrLen)
    val r2 = with(r1, ::getLenInfo)
    val r3 = with(r2, ::getInfoMap)
    with(r3, ::show)

    println()

    // 匿名操作
    with(with(with(with(str) {
        length
    }) {
        "你的字符串长度是:$this"
    }){
        "【$this】"
    }){
        println(this)
    }
}

fun getStrLen(str: String) = str.length
fun getLenInfo(len: Int) = "你的字符串长度是:$len"
fun getInfoMap(info: String) = "【$info】"
fun show(content: String) = println(content)

run函数

fun main(){
  val str = "Brett"
  val r = str.run{
  //this == str本身
     true
  }
  println(r)
}

内置函数总结

apply：info.apply
1.apply函数返回类型，都是info本身 此条和also函数一致
2.apply函数的匿名函数里面持有的是this == info本身 此条和run函数一致

let：
1.let函数返回类型，是根据匿名函数最后一行的变化而变化，此条和run函数一致
2.let函数的匿名函数里面持有的是it == 集合本身 此条和also函数一致

run：str.run
1.run函数返回类型，是根据匿名函数最后一行的变化而变化 此条和let函数一致
2.run函数的 匿名函数里面持有的是this == str本身 此条和apply函数一致

also：str.also
1.also函数返回类型 都是str本身 此条和apply函数一致
2.also函数的 匿名函数里面持有的是it == str 此条和let函数一致

with：with(str) with和run基本一致，只是使用的时候不同

takeIf函数

fun main() {
    val result = checkPermissionAction("Root2", "!@#$")
    // println("欢迎${result}尊贵的用户欢迎登录系统,拥有超级权限")
    if (result != null) {
        println("欢迎${result}尊贵的用户欢迎登录系统,拥有超级权限")
    } else {
        println("你的权限不够")
    }

    // name.takeIf { true/false }
    // true: 直接返回name本身
    // false: 直接放回null

    // 真正的用途
    println(checkPermissionAction2("Root", "!@#$"))

    // 小结：一般大部分情况下，都是 takeIf + 空合并操作符 = 一起使用
}
// takeIf + 空合并操作符
public fun checkPermissionAction2(name: String, pwd: String) : String {
    return name.takeIf { permissionSystem(name, pwd) } ?: "你的权限不够"
}

// 权限系统
private fun permissionSystem(username: String, userpwd: String) : Boolean {
    return if (username == "Root" && userpwd == "!@#$") true  else false
}

takeUnless

// takeIf 和 takeUnless 功能是相反的
// name.takeIf { true/false }  true:返回name本身，false返回null
// name.takeUnless { true/false }  false:返回name本身，true返回null

class Manager {

    private var infoValue: String? = null

    fun getInfoValue() /* : String? */ = infoValue

    fun setInfoValue(infoValue: String) {
        this.infoValue = infoValue
    }
}

fun main() {
    val manager = Manager()

    /*
    "Derry".takeIf { *//*it == "Derry"*//* }
    "Derry".takeUnless { *//*it == "Derry"*//* }
    */

    // manager.setInfoValue("AAA")

    // 小结：takeUnless+it.isNullOrBlank() 一起使用，可以验证字符串有没有初始化等功能
    val r  = manager.getInfoValue().takeUnless { it.isNullOrBlank() } ?: "未经过任何初始化值"
    println(r)
}