Android kotlin第二弹空判断 ?可空默认var val 声明的变量都不能赋值 null 加上？表示可空类

空判断

?可空

默认var val 声明的变量都不能赋值 null

加上？表示可空类型，执行代码的时候？可以避免空指针？为空后边语句不会执行

fun main() {
    var a: String? = "111"
    a = null
    println("length:${a?.length}")//length:null
}

!!断言慎用

fun main() {
    var a: String? = "111"
    a = null
    println("length:${a!!.length}")//空指针异常
}

if判断

fun main() {
    var a: String? = "111"
    a = null
    if（a!=null){
        println("length:${a.length}")
    }
}

空合并操作符号

fun main() {
    var a: String? = null
    //空合并操作符号  空执行后边
    println(a ?: "null")
    //let 函数 + 空合并操作符
    println(a?.let { "内容：$it" } ?: "null")
}

内置函数

apply

返回固定是 this 本身，不受内部代码影响
持有 this ，this == info
因为返回 info 本身，所以常常使用链式调用来操作, 分层功能

/**
 * 返回固定是 info 不受apply代码影响
 * 持有 this ，this == info
 * 因为返回 info 本身，所以常常使用链式调用来操作
 */
fun applyTest() {
    var info: String = "hello world"
    var ret = info.apply {
        //持有 this ，this == info 返回固定是 info 不受apply代码影响
        println(this.length)
        println(this[length - 1])
        println(this.replace(" ", "_"))
    }
    println(ret)//hello world
    //因为返回 info 本身，所以常常使用链式调用来操作
    info.apply {
        println(this.length)
    }.apply {
        println(this[length - 1])
    }.apply {
        println(this.replace(" ", "_"))
    }
}

let

符合 lamda 表达式，最后一行作为返回值，并类型推导
持有 it

/**
 * 符合 lamda 表达式，最后一行作为返回值，并类型推导
 * 持有 it
 */
fun letTest() {
    val list = listOf(1, 2, 3, 9, 5, 1)
    val first = list.first()
    val first1 = list.let {
        //符合 lamda 表达式，最后一行作为返回值，并类型推导
        it.first()
    }
    println("$first == $first1")
    var msg: String? = "rrr"
    //简化 三目运算， let 执行真  ?: 执行假
    var msg2 = msg?.let { "it:${it}" } ?: "null"
    println("msg2:$msg2")
}

run

符合 lamda 表达式，最后一行作为返回值，并类型推导
持有 this

/**
 * 符合 lamda 表达式，最后一行作为返回值，并类型推导
 * 持有 this
 */
fun runTest(){
    var info: String = "hello world"
    var ret = info.run {
        //持有 this ，this == info 返回固定是 info 不受apply代码影响
        println(this.length)
        println(this[length - 1])
        this.replace(" ", "_")
    }
    println(ret)
}

with

符合 lamda 表达式，最后一行作为返回值，并类型推导
持有 this
和 run 一样但是需要以传入参数的形式执行，不可链式调用

/**
 * 符合 lamda 表达式，最后一行作为返回值，并类型推导
 * 持有 this
 * 和 run 一样但是需要以传入参数的形式执行
 */
fun withTest(){
    var info: String = "hello world"
    val ret = with(info){
        this.replace(" ","_")
    }
    println(ret)
}

also

返回固定是 this 本身，不受内部代码影响
持有 it

takeif

持有it
内部函数必须返回boolean 真返回this，假返回null
配合空合并操作符号 ?: 返回一直为真的值

/**
 * 持有it
 * 内部函数必须返回boolean  真返回this， 假返回null
 */
fun takeifTest(){
    var info: String = "hello world"
    info.takeIf { 
        it.contains("world")
    }
}

takeUnless

持有it
内部函数必须返回boolean 真返回null，假返回this

/**
 * 持有it
 * 内部函数必须返回boolean  真返回null， 假返回this
 */
fun takeUnlessTest(){
    var info: String = "hello world"
    val ret = info.takeUnless {
        !it.contains("world")
    }
    println(ret)
}

集合

getOrElse getOrNull

fun main() {
    val list1 = listOf("11", "22", "33", "44")
    println(list1[1])
    println(list1.getOrNull(5) ?:  "5 outOfIndex" )
    println(list1.getOrElse(5) { "5 outOfIndex" })
}

可变和不可变集合

kotlin 推荐使用不可变集合

fun listTest(){
    val list1 = mutableListOf("11","22","33","44")
    list1.add("55")
    list1.remove("11")
    val list2 = list1.toList()//可变转不可变集合
    list2.toMutableList()//不可变转可变集合
    println(list1)
}

运算符重载 +=、-+

assign

fun mutatorTest() {
    val list1 = mutableListOf("11", "22", "33", "44")
    list1 += "cc"//运算符重载
    list1.removeIf(){
        it == "22"//带条件删除
    }
    println(list1)
}

遍历

fun travalsList() {
    val list1 = mutableListOf("11", "22", "33", "44")
    //方式1
    for (item in list1) {
        println("item:${item}")
    }
    //方式2
    list1.forEach {
        println("item:${it}")
    }
    //方式3
    list1.forEachIndexed() { index, item ->
        println("item:${index}: $item")
    }
}

解构

解构方法和 lamda 内部通过 _ 可以跳过声明变量，可以节约对象申请

fun jiegou() {
    val list1 = mutableListOf("11", "22", "33", "44")
    val (i1, i2, i3, i4) = list1
    val (_, i2, i3, i4) = list1
}

set 集合

相同元素会合并
使用防止下标越界的方式获取元素
尽量使用不可变集合，只读

fun jiegou() {
    val set1 = mutableSetOf("11", "22", "33", "33")
    var s1 = set1.elementAtOrElse(0)
    var s2 = set1.elementAtOrNull(1)
    
}

distinct 集合去重

list去重使用 distinct 函数直接去重

fun distinctTest(){
    val list1 = mutableListOf("11", "22", "33", "33")
    list1.distinct()
    println(list1)
}

数组类型

类型	方法
IntArray	intArrayOf
DoubleArray	doubleArrayOf
BooleanArray	booleanArrayOf
CharArray	charArrayOf
...
Array<?>	arrayOf<?>

避免越界的函数方式

elementAtOrElse

elementAtOrNull

xxxOrNull + 空合并操作符号 ?:

集合转数组

fun list2Array(){
     val list1 = listOf("11", "22", "33", "33")
     val array1 = list1.toIntArray()
     println(array1)
}

map

使用Pair创建map

fun mapTest() {
    val map1 = mapOf("11" to 11, "22" to 22, "33" to 33)
    val map2 = mapOf(Pair("11", 11), Pair("22", 22), Pair("33", 33))
    println(map1)
    println(map2)
}

getOrElse getOrDefault

1、安全获取map的Pair的方式 2、[] 操作符重载 get 3、不推荐使用 getValue 的方式

travels

//推荐使用forEach的方式

fun travelsMap(){
    val map1 = mapOf("11" to 11, "22" to 22, "33" to 33)
    map1.forEach(){
        println("${it.key}:${it.value}")
    }
}

getOrPut

获取时没有值会put 一个

fun getMap(){
    val map1 = mapOf("11" to 11, "22" to 22, "33" to 33)
    val v4 = map1.getOrPut("44"){44}
    println(v4)// 44
}

Android kotlin第二弹

空判断

?可空

!!断言 慎用