【Kotlin】集合操作总结 ( List 集合 | MutableList 集合 | List 集合遍历 | Set 集合 | MutableSet 集合 | Map 集合 | 可变 Map集合 )

文章目录

• ​​一、List 创建与元素获取​​
• ​​二、安全获取集合元素​​

• ​​1、getOrElse 函数​​
• ​​2、getOrNull函数​​

• ​​三、List 创建与元素获取代码示例​​
• ​​四、MutableList 可变列表集合​​
• ​​五、修改 MutableList 集合的 mutator 函数​​

• ​​1、添加元素运算符 += 和 删除元素运算符 -=​​
• ​​2、通过 Lambda 表达式筛选要删除的元素​​

• ​​六、List 集合遍历​​
• ​​七、List 通过解构一次性给多个元素赋值​​
• ​​八、Set 集合​​
• ​​九、可变 Set 集合​​
• ​​十、List 与 Set 之间相互转换​​
• ​​十一、数组类型​​
• ​​十二、Map 集合​​
• ​​十三、获取 Map 值​​
• ​​十四、Map 遍历​​
• ​​十五、可变 Map 集合​​

一、List 创建与元素获取

Kotlin 中的集合分为两类 , 只读集合 和 可变集合

调用 ​​listOf​​​ 函数 , 可以 直接创建 List 集合 ;
通过 ​​​[]​​ 下标可以 直接获取 List 集合中的元素 ;

fun main() {
    val list = listOf("Tom", "Jerry")
    println("${list[0]}")
}

上述代码执行结果 :

Tom

二、安全获取集合元素

除了使用 ​​[]​​ 下标获取 List 集合元素外 , Kotlin 还提供了 安全获取集合元素的 方法 : getOrElse 和 getOrNull

1、getOrElse 函数

List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T 函数原型 :

/**
 * 返回给定[index]处的元素，如果[index]不在列表范围内，则返回调用[defaultValue]函数的结果。
 */
@kotlin.internal.InlineOnly
public inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T {
    return if (index >= 0 && index <= lastIndex) get(index) else defaultValue(index)
}

参数分析 : 在该函数中 , 传入了两个参数 , 第一个参数是元素的索引 , 第二个参数是一个 Lambda 表达式 ; 该 Lambda 表达式的 Int 类型参数就是 ​​index: Int​​ 参数 ;

返回值分析 : 返回给定[index]处的元素，如果[index]不在列表范围内，则 返回调用[defaultValue]函数的结果。

2、getOrNull函数

List<T>.getOrNull(index: Int): T? 函数原型 :

/**
 * 返回给定[index]处的元素，如果[index]不在列表范围内，则返回' null '。
 */
public fun <T> List<T>.getOrNull(index: Int): T? {
    return if (index >= 0 && index <= lastIndex) get(index) else null
}

参数分析 : 在该函数中 , 传入函数索引参数 ;

返回值分析 : 返回给定[index]处的元素，如果[index]不在列表范围内，则返回’ null '。

三、List 创建与元素获取代码示例

代码示例 :

fun main() {
    var list = listOf("Tom", "Jerry")
    println("${list[0]}")

    println(list.getOrElse(2, {"UnKnown"}))
    println(list.getOrNull(3))
}

执行结果 :

Tom
UnKnown
null

四、MutableList 可变列表集合

使用 listOf 函数 创建的 List 集合 是 只读列表集合 ;

使用 mutableListOf 函数 创建的 MutableList 集合 是 可变列表集合 ;

调用 MutableList#toList 函数 , 可以 将 可变列表集合 转为 只读列表集合 ;

调用 List#toMutableList 函数 , 可以 将 只读列表集合 转为 可变列表集合 ;

代码示例 :

fun main() {
    // 创建可变列表集合
    var mutableList = mutableListOf("Tom", "Jerry")
    // 添加元素
    mutableList.add("Jack")
    // 删除元素
    mutableList.remove("Tom")
    println(mutableList)

    // 将 可变列表集合 转为 只读列表集合
    val list: List<String> = mutableList.toList()
    // 将 只读列表集合 转为 可变列表集合
    val mutable: MutableList<String> = list.toMutableList()
}

执行结果 :

[Jerry, Jack]

五、修改 MutableList 集合的 mutator 函数

修改 MutableList 集合 的 函数 统称为 mutator 函数 ;

1、添加元素运算符 += 和 删除元素运算符 -=

运算符重载 : MutableList 集合 还有一些 运算符重载 , 添加元素运算符 ​​+=​​​ 和 删除元素运算符​​ -=​​ ;

• 向 MutableList 集合 中添加一些元素 , 可使用 += 运算符 :

mutableList += "Jack"

其效果等同于

mutableList.add("Jack")

• 从 MutableList 集合 中删除一些元素 , 可使用 -= 运算符 :

mutableList -= "Tom"

其效果等同于

mutableList.remove("Tom")

2、通过 Lambda 表达式筛选要删除的元素

通过 Lambda 表达式筛选要删除的元素 : Lambda 表达式返回 boolean 值 , 如果返回 true , 则删除该元素 , 返回 false 则不处理该元素 ;

fun main() {
    // 创建可变列表集合
    val mutableList = mutableListOf("Tom", "Jerry")
    // 通过 Lambda 表达式筛选要操作的元素
    // 删除包含 字母 T 的元素
    mutableList.removeIf {
        it.contains("T")
    }
    println(mutableList)
}

执行结果 :

[Jerry]

六、List 集合遍历

List 集合遍历 :

• for in 循环遍历 :

// 使用 for in 循环遍历
    for (name in list) {
        println("for : $name")
    }

• forEach 遍历 :

/**
 * 在每个元素上执行给定的[action]。
 */
@kotlin.internal.HidesMembers
public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

• forEachIndexed 遍历并同时获取索引值 :

/**
 * 在每个元素上执行给定的[action]，提供元素的顺序索引。
 * @param [action]函数，它接受元素的索引和元素本身
 * 并对元素执行所需的操作。
 */
public inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit): Unit {
    var index = 0
    for (item in this) action(checkIndexOverflow(index++), item)
}

代码示例 :

fun main() {
    // 创建可变列表集合
    val list = listOf("Tom", "Jerry", "Jack")

    // 使用 for in 循环遍历
    for (name in list) {
        println("for : $name")
    }

    // 使用 forEach 遍历
    list.forEach {
        println("forEach : $it")
    }

    // 遍历时获取索引位置
    list.forEachIndexed { index, s ->
        println("$index : $s")
    }
}

执行结果 :

for : Tom
for : Jerry
for : Jack
forEach : Tom
forEach : Jerry
forEach : Jack
0 : Tom
1 : Jerry
2 : Jack

七、List 通过解构一次性给多个元素赋值

List 通过解构一次性给多个元素赋值 :

fun main() {
    // 创建可变列表集合
    val list = listOf("Tom", "Jerry", "Jack")

    // 使用 list 集合一次性给 3 个元素赋值
    val (name1, name2, name3) = list

    println("name1 = $name1")
    println("name2 = $name2")
    println("name3 = $name3")
}

执行结果 :

name1 = Tom
name2 = Jerry
name3 = Jack

如果集合中有 3 个元素 , 但是只需要给 2 个元素赋值 , 这里可使用 ​​_​​ 跳过某个元素的赋值 ;

代码示例 :

fun main() {
    // 创建可变列表集合
    val list = listOf("Tom", "Jerry", "Jack")

    // 使用 list 集合一次性给 2 个元素赋值, 第 1 个元素跳过
    val (name1, _, name3) = list

    println("name1 = $name1")
    println("name3 = $name3")
}

执行结果 :

name1 = Tom
name3 = Jack

八、Set 集合

List 集合中的元素是 可以重复 的 , Set 集合中的元素 不可重复 ;

调用 setOf 函数

调用 Set#elementAt 函数 , 可以 读取 Set 集合中的元素 ;

代码示例 :

fun main() {
    val set = setOf("Tom", "Jerry", "Jack")
    println(set.elementAt(1))
}

执行结果 :

Jerry

九、可变 Set 集合

调用 mutableSetOf 函数 , 可以创建 可变 Set 集合 ;

可变 Set 集合 , 可以

• 使用 ​​+=​​ 运算符 添加元素
• 使用 ​​-=​​ 运算符删除元素 ;

代码示例 :

fun main() {
    val mutableSet = mutableSetOf("Tom", "Jerry", "Jack")
    mutableSet += "Bill"
    mutableSet -= "Jerry"

    println(mutableSet)
    println(mutableSet.elementAt(2))
}

执行结果 :

[Tom, Jack, Bill]
Bill

十、List 与 Set 之间相互转换

调用 List#toSet() 函数 , 可以将 List 集合转为 Set 集合 , 转换过程中会 自动删除重复的元素 ;

调用 List#distinct() 函数

调用 Set#toList() 函数 , 可以将 Set 集合转为 List 集合 ;

代码示例 :

fun main() {
    val list = listOf("Tom", "Jerry", "Jack", "Tom", "Jerry", "Jack")
    println(list)
    println(list.distinct())

    val list2 = listOf("Tom", "Jerry", "Jack", "Tom", "Jerry", "Jack")
    val set = list2.toSet()
    println(set)
}

执行结果 :

[Tom, Jerry, Jack, Tom, Jerry, Jack]
[Tom, Jerry, Jack]
[Tom, Jerry, Jack]

十一、数组类型

数组类型 :

• Int 类型数组 : IntArray 数组类型 , 使用 intArrayOf 函数创建 ;
• Double 类型数组 : DoubleArray 数组类型 , 使用 doubleArrayOf 函数创建 ;
• Long 类型数组 : LongArray 数组类型 , 使用 longArrayOf 函数创建 ;
• Short 类型数组 : ShortArray 数组类型 , 使用 shortArrayOf 函数创建 ;
• Byte 类型数组 : ByteArray 数组类型 , 使用 byteArrayOf 函数创建 ;
• Float 类型数组 : FloatArray 数组类型 , 使用 floatArrayOf 函数创建 ;
• Boolean 类型数组 : BooleanArray 数组类型 , 使用 booleanArrayOf 函数创建 ;
• 普通对象类型数组 : Array 数组类型 , 使用 arrayOf 函数创建 ;

代码示例 :

fun main() {
    var intArray = intArrayOf(0, 1, 2, 3)
    var doubleArray = doubleArrayOf(0.1, 0.2, 0.3)
    var longArray = longArrayOf(0, 1, 2, 3)
    var shortArray = shortArrayOf(0, 1, 2, 3)
}

十二、Map 集合

调用 mapOf 函数 创建 Map 集合 , 键值对 元素有两种初始化方式 :

• 使用 to 函数进行初始化 : 在参数中使用 ​​键 to 值​​ 的方式进行初始化 ;
• 使用 Pair 对象进行初始化 : 传入 ​​Pair(键, 值)​​ 进行初始化 ;

to 函数原型如下 , 其本质也是返回 Pair 类型的实例对象 ;

/**
 * 从this和[that]创建类型为[Pair]的元组。
 * 这对于创建噪音更少的[Map]字面量很有用，例如:
 * @sample samples.collections.Maps.Instantiation.mapFromPairs
 */
public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)

代码示例 :

fun main() {
    val map = mapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20)
    println(map)

    val map2 = mapOf(Pair("Tom", 18), Pair("Jerry", 12), Pair("Jack", 20))
    println(map2)
}

执行结果 :

{Tom=18, Jerry=12, Jack=20}
{Tom=18, Jerry=12, Jack=20}

十三、获取 Map 值

获取 Map 值 :

• 使用 取值运算符 ​​[]​​ 获取 Map 集合中的值
• 使用 Map#getValue 函数

public fun <K, V> Map<K, V>.getValue(key: K): V = getOrImplicitDefault(key)

• 使用 Map#getOrElse 函数

public inline fun <K, V> Map<K, V>.getOrElse(
    key: K, 
    defaultValue: () -> V): V = get(key) ?: defaultValue()

• 使用 Map#getOrDefault 函数

public fun getOrDefault(key: K, defaultValue: @UnsafeVariance V): V {
        // See default implementation in JDK sources
        throw NotImplementedError()
    }

代码示例 :

fun main() {
    val map = mapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20)
    println(map)

    val map2 = mapOf(Pair("Tom", 18), Pair("Jerry", 12), Pair("Jack", 20))
    println(map2)

    // 使用 取值运算符 `[]`  获取 Map 集合中的值 , 运算符中传入 键 , 如果找不到 键 对应的 值 , 返回 null
    println(map["Tom"])

    // 使用 Map#getValue 函数 , 获取 键 对应的 值 , 如果没有找到则抛出异常
    println(map.getValue("Tom"))

    // 使用 Map#getOrElse 函数 ,  获取 键 对应的 值 , 如果没有找到则返回 Lambda 表达式 参数 的返回值
    println(map.getOrElse("Tim", {20}))

    // 使用 Map#getOrDefault 函数 , 获取 键 对应的 值 , 如果没有找到则返回默认值
    println(map.getOrDefault("Tim", 88))
}

执行结果 :

{Tom=18, Jerry=12, Jack=20}
{Tom=18, Jerry=12, Jack=20}
18
18
20
88

十四、Map 遍历

Map 遍历方式 :

• forEach 函数 , 传入 Lambda 表达式参数 , 该 Lambda 表达式的参数为 ​​Map.Entry<K, V>​​ 类型 ;

public inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit): Unit {
    for (element in this) action(element)
}

• forEach 函数 , 传入 Lambda 表达式参数 , 该 Lambda 表达式的 两个参数为 实际的 键值对 的类型 ;

default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

代码示例 :

fun main() {
    val map = mapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20)
    println(map)

    map.forEach {
        // 可操作 Entry 对象
        println("${it.key} = ${it.value}")
    }

    map.forEach { key: String, value: Int ->
        // 可获取具体的键和值
        println("$key = $value")
    }
}

执行结果 :

{Tom=18, Jerry=12, Jack=20}
Tom = 18
Jerry = 12
Jack = 20
Tom = 18
Jerry = 12
Jack = 20

十五、可变 Map 集合

通过调用 mutableMapOf 函数 , 可创建 可变 Map 集合 ;

代码示例 :

fun main() {
    val mutableMap = mutableMapOf("Tom" to 18, "Jerry" to 12, "Jack" to 20)
    println(mutableMap)

    // 增加元素
    mutableMap += "Rose" to 18
    mutableMap.put("Tim", 21)
    println(mutableMap)

    // 查询是否有 某个键 对应的值, 如果没有则添加一个默认值进去
    mutableMap.getOrPut("Kate", {19} )
    println(mutableMap)
}

执行结果 :

{Tom=18, Jerry=12, Jack=20}
{Tom=18, Jerry=12, Jack=20, Rose=18, Tim=21}
{Tom=18, Jerry=12, Jack=20, Rose=18, Tim=21, Kate=19}