Kotlin笔记（二）

字符串操作

const val NAME = "Kevin's friend"
const val NAME_ARR = "Kevin,Jack,Lily"
const val CHINA = "The People's Republic of China"
fun main() {
    //截取Kevin
    val index = NAME.indexOf("\'")
    println(NAME.substring(0, index))
    println(NAME.substring(0 until index))
    //字符串分割
    println(NAME_ARR.split(","))
    //解构语法
    val (a, b, c) = NAME_ARR.split(",")
    println("a的名字是${a}，b的名字是${b}，c的名字是${c}")
    //配合when进行字符替换
    val china2 = CHINA.replace(Regex("[aeiou]")) {
        when(it.value) {
            "a" -> "1"
            "e" -> "2"
            "i" -> "3"
            "o" -> "4"
            "u" -> "5"
            else -> it.value
        }
    }
    println(china2)
    //比较 ==为比较相同字符串  ===为比较相同内存对象
    val str1 = "Kevin"
    val str2 = "Kevin"
    println(str1 == str2)
    println(str1 === str2)
    val s1 = "Kevin"
    val s2 = "kevin".capitalize()
    println(s1 == s2)
    println(s1 === s2)
    val sb1 = StringBuilder("1")
    val sb2 = sb1
    println(sb1 == sb2)
    println(sb1 === sb2)
    //遍历
    CHINA.forEach {
        println(it)
    }
    //转换失败抛异常NumberFormatException
//    println("9.99".toInt())
    //转换失败返回null
    println("9.99".toIntOrNull())
    //精度损失
    println(9.99.toInt())
    //四舍五入
    println(9.99.roundToInt())
    //格式化(保留小数点后两位，末尾采取四舍五入)
    val p = "%.2f".format(3.1415926)
    println(p)
}

apply，let，run，also

fun main() {
    //apply方法中this代表当前对象，可以通过隐式调用this操作该对象，并返回该对象
    val book = Book().apply {
        name = "apply"
        page = 10
        changeName("apply apply")
    }
    println(book.name)
    println(book.page)
    //let方法中it代表当前对象，需要通过it显式调用操作该对象，最后一行表示返回的对象
    val book2 = Book().let {
        it.name = "let"
        it.page = 20
        it.changeName("let let")
        it
    }
    println(book2.name)
    println(book2.page)
    //run方法和apply一样传入隐式的this，和let一样最后一行表示返回的对象
    val book3 = Book().run {
        name = "run"
        page = 30
        changeName("run run")
        this
    }
    println(book3.name)
    println(book3.page)
    //run通过函数引用实现链式调用，下一个方法的入参是上一个方法的出参
    "12345678910".run(::checkMax).run(::getMessage).run(::println)
    //with方法和run方法相同，不过调用者要作为入参放入后面括号中（with方法不常用）
    val book4 = with(Book()){
        name = "with"
        page = 40
        changeName("with with")
        this
    }
    println(book4.name)
    println(book4.page)
    //also和let一样传入需要显示调用的it作为当前对象，和apply一样直接返回该对象
    val book5 = Book().also {
        it.name = "also"
    }.also {
        it.page = 50
    }.also {
        it.changeName("also also")
    }
    println(book5.name)
    println(book5.page)
}

private fun checkMax(str:String) : Boolean {
    return str.length > 10
}

private fun getMessage(isMax:Boolean) : String {
    return if (isMax) {
        "is max"
    } else {
        "not max"
    }
}

private class Book {
    var name:String? = null
    var page:Int? = null

    fun changeName(name:String) {
        this.name = name
    }
}

takeIf，takeUnless

fun main() {
    val str = "aaa"
    //takeIf方法表示判断方法体中的条件是否满足，若满足则返回该对象进行接下来的操作，若不满足则返回null
    val res = str.takeIf {
        it == "aaa"
    }?.replace("a", "b")
    println(res)
    //takeUnless和takeIf刚好相反，不满足条件返回该对象，满足返回null
    val res2 = str.takeUnless {
        it == "aaa"
    }?.replace("a", "b")
    println(res2)
}

集合创建

fun main() {
    //创建不可变的集合
    val list = listOf("AAA", "BBB", "CCC")
    //安全索引函数
    //getOrElse方法表示若下标越界则返回方法体中的结果
    println(list.getOrElse(3){"DDD"})
    //getOrNull方法表示若下标越界返回空
    println(list.getOrNull(3) ?: "DDD")

    //创建可变的集合
    val list2 = mutableListOf<String>()
    list2.add("AAA")
    list2.add("BBB")
    list2.add("CCC")
    println(list2.toString())
    list2.removeAt(1)
    list2.remove("CCC")
    println(list2.toString())

    //可变集合与不可变集合的转换
    val list3 = list2.toList()
    println(list3.toString())
    val list4 = list.toMutableList()
    println(list4.toString())
}

集合操作

fun main() {
    val list = mutableListOf<String>()
    //源码中通过运算符重载添加和移除元素
    list += "AAA"
    list += "BBB"
    list += "CCC"
    list += "DDD"
    println(list.toString())
    list -= "AAA"
    println(list.toString())
    //removeIf通过条件删除元素
    list.removeIf{
        it == "CCC"
    }
    println(list.toString())
    //集合遍历
    for (s in list) {
        println(s)
    }
    list.forEach {
        println(it)
    }
    list.forEachIndexed { index, s ->
        println("[${index},${s}]")
    }
    //集合的解构语法
    val list2 = listOf("1", "2", "3")
    val (a, b, c) = list2
    println("a=${a},b=${b},c=${c}")
    //下划线表示跳过解构此下标的元素，编译码中也会跳过，提高性能
    val (e, _, f) = list2
    println("e=${e},f=${f}")
}

Set集合

fun main() {
    //不能重复集合set和list基本一样
    val set = setOf("1", "2", "3")
    println(set.elementAtOrElse(3){"4"})
    println(set.elementAtOrNull(3) ?: "4")

    val set2 = mutableSetOf<String>()
    set2 += "1"
    set2 += "2"
    set2 += "3"
    set2.remove("1")
    set2.forEachIndexed { index, s ->
        println("[${index},${s}]")
    }
}

集合去重

fun main() {
    val list = listOf("AAA", "BBB", "CCC", "CCC", "BBB")
    //list集合去重，先转set再转回list
    val list2 = list.toSet().toList()
    list2.forEach {
        println(it)
    }
    //提供快捷去重api
    val list3 = list.distinct()
    list3.forEach {
        println(it)
    }
}

数组

fun main() {
    //创建int类型的数组
    val intArr = intArrayOf(1, 2, 3)
    //集合转数组
    val intArr2 = listOf(1, 2, 3).toIntArray()
    //创建对象数组
    val peopleArr = arrayOf(People("小明", 23), People("小方", 20), People("小强", 28))
    intArr.forEach {
        println(it)
    }
    intArr2.forEach {
        println(it)
    }
    peopleArr.forEach {
        println(it.toString())
    }
}

private class People(private var name: String?, private var age: Int?) {

    override fun toString(): String {
        return "姓名：${name}，年龄：$age"
    }
}

Map集合

fun main() {
    //map的创建实则是传入Pair对象，to方法生成该对象
    val map1 = mapOf("Kevin" to 22, "Json" to 25)
    println(map1)
    val map2 = mapOf(Pair("Kevin", 22), Pair("Json", 25))
    println(map2)

    //map根据key获取value
    //为空不会抛出异常直接返回null
    println(map2["Kevin"])
    //为空抛出异常
    println(map2.getValue("Kevin"))
    //为空返回后面的对象（可以不为value的类型）
    println(map2.getOrElse("Rose"){"未知年龄"})
    //为空返回value的默认值（必须是value的类型）
    println(map2.getOrDefault("Rose", 0))

    //map的遍历
    map2.forEach {
        println("key = ${it.key}, value = ${it.value}")
    }
    map2.forEach{(a:String, b:Int) ->
        println("key = $a, value = $b")
    }

    //可变map操作方式
    val map3 = mutableMapOf<String, Int>()
    map3 += "Kevin" to 22
    map3["Json"] = 25
    //getOrPut方法获取为空的情况添加一条进去
    println(map3.getOrPut("Rose"){28})
    println(map3)
}