List、Set、Map

集合概述

集合的引入，在程序中，我们可以通过数组来保存多个对象，数组的程度也就是个数是确定的，如果我们无法确定需要保存的对象的多少，那么数组就不能满足存储的要求，此时，KT引入了集合，集合可以存储任意类型的对象，并且长度可变
定义：集合类似一个容器，用于存储一系列的对象，这些对象可以是任意的数据类型，并且长度可变

• 集合按照其存储结构可以分为：单列集合（Collection）、双列集合（Map）

单列集合：

单列集合.png

1. List 特点：有序 可重复 线性方式存储 元素的存和取顺序一致 可通过索引来访问集合中的元素
   分为可变集合（MutableList）和不可变集合（List）
   可变集合（MutableList）：可以对集合中的元素进行增删操作
   不可变集合（List）：对集合中的元素仅提供只读操作

fun main() {
    // 不可变 只读
    var list = listOf(22, 33, 33, 44, 44)
    println(list.size)// 集合大小
    println(list.get(2))// 下标为2的元素
    println(list.indexOf(33))// 元素为33的下标
    println(list.lastIndexOf(44))// 最后一个元素为44的下标
    println(list.subList(1, 3))// 截取集合中索引1-3的元素 不包含3
    // 集合元素遍历
    list.forEach { value ->
        println("list 元素$value")
    }
    // 带有下标的集合元素遍历
    list.forEachIndexed { index, value ->
        println("list 下标$index 元素$value")
    }
    println(list.isEmpty())// 判断集合是否为空
    val iterator = list.iterator()// 集合元素迭代器
    while (iterator.hasNext()) {
        println(iterator.next())
    }

    // 可变 可读可写（增删改查）
    val mutableListOf = mutableListOf(22, 33, 44, 44)
    println(mutableListOf.size)
    println(mutableListOf.get(2))
    println(mutableListOf.indexOf(44))
    println(mutableListOf.lastIndexOf(44))
    mutableListOf.set(2, 88)// 修改元素 22 33 88 44
    mutableListOf.forEach { value ->
        println("mutableList 元素修改后$value")
    }
    mutableListOf.add(55)// 添加元素 22 33 88 44 55
    mutableListOf.forEachIndexed { index, value ->
        println("mutableList 下标$index 元素添加后$value")
    }
    mutableListOf.removeAt(2)// 删除元素 22 33 44 55
    mutableListOf.forEach { value ->
        println("mutableList 元素删除后$value")
    }
    var mutList = mutableListOf(88,66) // 添加集合 22 33 44 55 88 66
    mutableListOf.addAll(mutList)
    mutableListOf.forEach { value ->
        println("mutableList 添加集合后元素$value")
    }
    if (mutableListOf.containsAll(mutList)) {
        // mutableListOf包含mutList集合 从集合mutableListOf中删除mutList
        mutableListOf.removeAll(mutList)// 删除集合 22 33 44 55
    }
    mutableListOf.forEach { value ->
        println("mutableList 删除集合mutList后元素$value")
    }
    mutableListOf.clear()// 清除集合 0
    println(mutableListOf.size)
}

2. Set 特点：无序 不可重复
   分为可变集合（MutableSet）和不可变集合（Set）
   可变集合（MutableSet）：可以对集合中的元素进行增删操作
   不可变集合（Set）：对集合中的元素仅提供只读操作

/**
 * 不可变集合
 */
fun notChangeSet() {
    var set1 = setOf(22, 33, 55, 88)
    var set2 = setOf(22, 66, 88, 55, 33)

    println(set1.size)
    println(set2.size)

    if (set1.contains(22)) {
        println(" 包含元素 22 ")
    }

    if (set2.containsAll(set1)) {
        println(" 包含集合 set1 ")
    }

    if (set1.isNotEmpty()) {
        println(" 有数据 ")
    }

    val iterator = set1.iterator()
    while (iterator.hasNext()) {
        println(iterator.next())
    }

}

/**
 * 可变集合
 */
fun changeSet() {
    var set1 = mutableSetOf(22, 55, 44, 88)
    var set2 = mutableSetOf(22, 44, 55, 99, 88, 77)

    if (set2.containsAll(set1)) {
        println(" 包含集合set1 ")
    }

    set1.add(11)

    val iterator = set1.iterator()
    while (iterator.hasNext()) {
        println(iterator.next())
    }
    println("-----------------------")
    set1.remove(88)
    val iterator1 = set1.iterator()
    while (iterator1.hasNext()) {
        println(iterator1.next())
    }
    println("========================")
    set2.removeAll(set1)

    val iterator2 = set2.iterator()
    while (iterator2.hasNext()) {
        println(iterator2.next())
    }

}

3. MutableCollection 特点：元素可变

双列集合：

双列集合.png

3. Map特点：元素可重复 以键值对的形式存储 键和值对象之间存在一种对应关系 称为映射
   分为可变集合（MutableMap）和不可变集合（Map）
   可变集合（MutableMap）：可以对集合中的元素进行增删操作
   不可变集合（Map）：对集合中的元素仅提供只读操作

fun main() {
    //notChangeMap()
    changeMap()
}

/**
 * 不可变集合
 */
fun notChangeMap() {
    var map1 = mapOf(1 to "小黄", 2 to "小李子", 3 to "小杨杨")

    println(map1.contains(1))

    println(map1.containsKey(2))

    println(map1.containsValue("小李子"))

    println(map1.size)

    println(map1.isNotEmpty())

    println(map1.get(2))

    /*map1.forEach {
        println(it.key)
        println(it.value)
    }*/

    val entries = map1.entries
    val iterator = entries.iterator()
    while (iterator.hasNext()) {
        println(iterator.next())
    }

}

/**
 * 可变集合
 */
fun changeMap() {
    var map1 = mutableMapOf(1 to "小样", 2 to "小赵")
    var map2 = mutableMapOf(3 to "小杨丽")

    map1.put(2, "小王")

    val iterator = map1.entries.iterator()
    while (iterator.hasNext()) {
        println(iterator.next())
    }

    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
        map1.replace(1, "小万把")
    }

    val iterator1 = map1.entries.iterator()
    while (iterator1.hasNext()) {
        println(iterator1.next())
    }

    map1.remove(2)

    val iterator2 = map1.entries.iterator()
    while (iterator2.hasNext()) {
        println(iterator2.next())
    }

    map1.putAll(map2)
    val iterator3 = map1.entries.iterator()
    while (iterator3.hasNext()) {
        println(iterator3.next())
    }

}