【笔记】Kotlin的List集合

前言

Kotlin的List集合学习笔记

创建List集合

创建空List集合

var list: List<数据类型> = emptyList()

创建可变List集合并添加元素

var list: MutableList<数据类型> = mutableListOf(值, 值)

创建只读List集合并添加元素

• 只读List集合只能获取元素，不能增删元素

var list: List<数据类型> = listOf(值, 值)

创建List集合并添加元素

var list: List<数据类型> = List(<num>) {
    值
}

创建不含null值的List集合并添加元素

• 如果插入null值会被过滤

var list: List<数据类型> = listOfNull(值, 值)

操作符

获取元素

var value = list[<num>]

修改元素

list[<num>] = 值

合并List集合

• 返回Set集合

var list1 = listOf<数据类型>()
var list2 = listOf<数据类型>()

var result = list1 + list2

var list1 = listOf<数据类型>()
var list2 = listOf<数据类型>()

var result = list1 union list2

求并集

• 合并List集合并去重

var list1 = listOf<数据类型>()
var list2 = listOf<数据类型>()

var result = list1 - list2

实例方法

添加元素

list.add(值)

向指定位置添加值

• <index>的取值范围为[0,list.size()]

list.add(<index>, 值)

删除元素

list.removeAt(<index>)

list.remove(值)

映射

var result = list.map {
    it
}

压缩和解压

压缩

• 两个List集合转换为映射列表

var list1 = listOf<键数据类型>()
var list2 = listOf<值数据类型>()

var map: List<Pair<键数据类型, 值数据类型>> = list1.zip(list2)

解压

• 映射列表转换为两个List集合

var map = mapOf<键数据类型, 值数据类型>()

var list: Pair<List<键数据类型>, List<值数据类型>> = map.unzip()
var list1 = list.first
var list2 = list.second

List集合转换为Map集合

var list = listOf(键, 键)

var map: Map<键数据类型, 值数据类型> = list.associateWith {
    值
}

var list = listOf(值, 值)

var map: Map<键数据类型, 值数据类型> = list.associateBy {
    键
}

var list = listOf(值, 值)

var map: Map<键数据类型, 值数据类型> = list.associate {
    键 to 值
}

平铺多集List为List集合

var list1 = listOf<数据类型>()
var list2 = listOf<数据类型>(list1)

var list = list2.flatten()

var list1 = listOf<数据类型>()
var list2: List<Container> = listOf<数据类型>(Container(list1), Container(list1))

var list = list2.flatMap {
    值
}

拼接数组为字符串

• 默认使用, 作为分隔符

list.joinToString()

• 定义分隔符

list.joinToString("分隔符")

• 定义分隔符，前缀，后缀

list.joinToString(separator = "分隔符", prefix = "前缀", postfix = "后缀")

• 定义将前<num>个元素拼接为字符串，超出部分显示为...

list.joinToString(limit = <num>, truncated = "...")

• 遍历所有元素，自定义每次拼接的内容

list.joinToString {
    it.toString()
}

过滤

自定义过滤元素

var result = list.filter {
    true
}

去除null值

var result = list.filterNotNull()

只保留特定类型的值

var result = list.filterIsInstance<数据类型>()

匹配

match：匹配成功的List集合
mismatch：匹配失败的List集合

var (match, mismatch) = list.partition {
    true
}

判断集合中元素是否满足条件

至少有一个满足条件

var result = list.any {
    true
}

全满足条件

var result = list.all {
    true
}

全不满足条件

var result = list.none {
    true
}

分组

根据条件分组

var map: Map<数据类型, List<数据类型>> = list.groupBy {
    it.length
}

根据长度分组

var list: List<List<数据类型>> = list.chunked(<num>)

截取

切片

var list = list.since(<num_start>..<num_end>)

从开始位置截取一部分元素

• 从开始位置截取<num>个元素

var list = list.take(<num>)

从截止位置截取一部分元素

• 从截止位置截取<num>个元素

var list = list.takeLast(<num>)

从开始位置丢弃一部分元素

• 从开始位置丢弃<num>个元素，保留其他的元素

var list = list.drop(<num>)

从截止位置丢弃一部分元素

• 从截止位置丢弃<num>个元素，保留其他的元素

var list = list.dropLast(<num>)

自定义截取

• 从开始位置截取，直到返回false终止截取

var list = list.takeWhile {
    true
}

遍历List集合

for (item in list) {
    println(item)
}

list.forEach {
    println(it)
}

list.forEach(::println)

list.list.forEachIndexed { index, item
    println(index)
    println(item)
}

完成

参考文献

哔哩哔哩——青空の霞光