@[TOC](kotlin 数组、集合和 Map 的使用)

前言

使用纯代码 加 注释的方式，可以更快的理解源码
如果你喜欢，请点个赞，后期会不断的深入讲解

1、List 创建与元素获取

   val list = listOf("张三","大漂亮","王美丽","王五")

//    正常取值方式： 索引， 内部是运算符重载 [] = get
    println(list[0])
    println(list[1])
    println(list[2])
    println(list[3])
  //  println(list[4])     //  下标越界崩溃     Index 4 out of bounds for length 4

//    kotlin 中，可以使用 getOrElse 和 getOrNull ，解决空指针异常，下标越界的崩溃异常
//    getOrElse 在取值越界的时候，会直接返回{"啊呀，你越界了，我出来了哦"} 括号里面定义的参数
    println(list.getOrElse(0){"你没有越界，我不会出来的"})
    println(list.getOrElse(4){"啊呀，你越界了，我出来了哦"})

//    getOrNull 在下标越界的时候，会返回一个null ，我们可以 + 空合并操作符， 使其返回一个字符
    println(list.getOrNull(0))
    println(list.getOrNull(4))


    println(list.getOrNull(4) ?: "没错，就是这里越界了，我使用空合并操作符出来了")

2、可变List 集合

//    不可变集合
    val list1 = listOf("张三","大漂亮","王美丽","王五")
    println(list1)
//    可变集合
    val list2 =  mutableListOf("张三","大漂亮","王美丽","王五")
    list2.add("tiger")
    list2.remove("王五")
    println(list2)
//    不可变集合 to 可变集合
    val list3 = list1.toMutableList()
    list3.remove("大漂亮")
    list3.add("tiger")
    println(list3)

//    可变集合 to 不可变集合
    val list4 = list2.toList()
//    list4.add     没有添加和删除方法
    println(list4)

3、mutator 函数

    val list2 =  mutableListOf("张三","大漂亮","王美丽","王五")
//    mutator 的特性 += -= 其实背后就是 运算符重载而已
    list2 += "tiger"
    list2 += "tt"
    list2 -= "tt"
    println(list2)

//    removeIf
  //  list2.removeIf{true}    //  如果返回的值是 true ，list2 就会自动遍历整个可变集合，一个一个的移除所有的数据
    list2.removeIf{it.contains("t")}   // 过滤集合中的所有元素，只要包含 t  的数据元素，就会被移除

    println(list2)

4、List 集合遍历 三种常用方式

    val list2 = mutableListOf("张三", "大漂亮", "王美丽", "王五")
//    1、 for 循环遍历
    for (i in list2) {
        print("元素是: $i  ")
    }
    println()
//    2、forEach 遍历
    list2.forEach {
        print("元素是： $it")
    }
    println()
//    3、forEachIndexed 获取下标和元素的遍历
    list2.forEachIndexed { index, item ->
        print("下标是：$index, 元素是：$item")
    }

5、结构语法过滤

    val list2 = mutableListOf("张三", "大漂亮", "王美丽", "王五")
//  集合配合结构语法
    val (v1, v2, v3) = list2
    println(v1)
    println(v2)
    println(v3)

//    val 是只读的数据遍历，可以使用var 修改结构出来的数据
    var (v11, v22, v33) = list2
    v22 = "tiger"
    println(v1)

//    也可以使用 _ 符号，来屏蔽你不需要的接收值，算是数据优化，可以优化内存
    val (_, v222, v333) = list2
    println(v222)
    println(v333)

6、set 集合

set 集合，元素不能重复

//    set 集合，元素不能重复
    val set = setOf("张三", "大漂亮", "王美丽", "王五", "大漂亮")
//    set 集合普通的取值方式
//    set[0]      在set 中，没有[] 这样的功能， 取set 的集合值
    set.elementAt(0)
//    set.elementAt(5)        这里会越界崩溃
//    set 集合 和list 集合一样，给我们提供了一种有效的取值方式，可以避免下标越界等情况的出现
    set.elementAtOrElse(0){"不越界，我就不会出来"}
    set.elementAtOrElse(6){"越界了哦，我出来啦"}
    set.elementAtOrNull(0)
    set.elementAtOrNull(6) ?: "越界啦，你返回了null，空合并操作符，让我出来和你见面"

7、可变的set 集合

//    list 中，有可变的集合，set 当然也会有啦。包括集合转变什么的，参照list 就可以
    val set = mutableSetOf("张三", "大漂亮", "王美丽", "王五", "大漂亮")
    set.add("tiger")
    set.remove("王五")
    set.removeIf{
        it.contains("王")
    }

    println(set)

8、集合转换与快捷函数

    val list = mutableListOf("张三", "大漂亮", "王美丽", "王五", "大漂亮")
//    list 转set 去重
    println(list.toSet())
//    list 转set 去重，再转回list
    println(list.toSet().toList())
//    使用快捷去重函数 distinct 
    println(list.distinct())    // 其实就是内部封装了一下，先把List 转换成 可变长度的set 再转换成list ，和上面的操作是一样的
    
    

9、数组类型

在kotlin 语言中，各种数组类型，虽然使用的是引用类型，背后可以编译成Java 基本类型

IntArray         intArrayOf
DoubleArray      doubleArrayOf
LongArray        longArrayOf
ShortArray       shortArrayOf
ByteArray        byteArrayOf
FloatArray       floatArrayOf
BooleanArray     booleanArrayOf
Array<对象类型>   arrayOf    对象数组

    val intArray = intArrayOf(1, 23, 32, 5, 2, 3)
//    其实数组和之前说的集合都是一样的，简单的，不再赘述
    intArray[3]
//    intArray[7]    下标越界，

    intArray.elementAtOrElse(3) { -1 }
    intArray.elementAtOrNull(66) ?: -1

//    list 集合转数组
    val set = intArray.toSet()
    println(set)

//    Array<对象数组>

    val array = arrayOf(File("文件路径"), File("文件路径"), File("文件路径"))
    println(array)

10、Map 的创建

//    在kotlin 中，下面两种创建map 的方式，其实是等价的
    val map = mapOf("tiger" to "111", "ss" to "333")
    val map1 = mapOf(Pair("tiger", "111"), Pair("tiger2", ""))
    

11、读取Map 的值

    val map = mapOf("tiger" to 122, "tiger2" to 333)
    
//    方法一 找不到会返回一个null
    println(map["tiger"])
    println(map["tiger333"])     //  返回null
//    方法二 和数组集合是一样的
    println(map.getOrElse("tiger") {-1})
    println(map.getOrElse("tiger222") {-1})     //找不到会返回-1
    
//    方法三 getOrDefault
    println(map.getOrDefault("tiger", -1))
    println(map.getOrDefault("tiger4444", -1))  //找不到会返回-1
//    方法四  getValue
    println(map.getValue("tiger"))
    println(map.getValue("tiger666"))      //找不到会直接崩溃

12、Map 的遍历

    val map = mapOf(Pair("tiger", 12), Pair("tiger2", 34), Pair("tiger3", 44), Pair("tiger4", 66))


//    第一种
    for (i in map){
        println(i)
        println(i.key)
        println(i.value)
    }

//    第二种
    map.forEach{
//         这个it 包含了 key value
        println(it)
        println(it.key)
        println(it.value)
    }

13、可变的Map 集合

  val map = mutableMapOf(Pair("tiger", 12), Pair("tiger2", 34), Pair("tiger3", 44), Pair("tiger4", 66))

//    其实就和集合数组一样的操作
//    可变集合的操作 -= += [] put
    map += "tiger222" to 322
    map -= "tiger222"
    map["dddd"] = 3000
    map.put("ssss", 333)

    println(map)

//    getOrPut 没有传入的 tiger555 key的话，他会把这个数据，插入进整个集合

    println(map.getOrPut("tiger555") { 7777 })
    //    getOrPut 当需要获取的key，在集合中找到了，就直接获取集合中的对应的value 值

    println(map.getOrPut("tiger555") { 999 })

总结

🤩
🎉 $\textcolor{blue}{原创不易，还希望各位大佬支持一下}$

👍 $\textcolor{green}{点赞，你的认可是我创作的动力！}$

🌟 $\textcolor{green}{收藏，你的青睐是我努力的方向！}$

✏️ $\textcolor{green}{评论，你的意见是我进步的财富！}$