kotlin学习日志5 - 集合

kotlin集合操作

kotlin集合的不同

kotlin在集合这方面与大多数语言不同,分只读集合和读写集合,这种良好的设计有利于在使用的过程中避免bug的出现

集合的创建

读写集合是只读集合的子类,可以将一个读写集合赋值给只读集合引用

// list
val list1 = listOf<Int>() // 创建kotlin只读集合
val list2 = mutableListOf<Int>() // 创建kotlin读写集合
val list3 = arrayListOf<Int>() // 创建java arraylist集合,这是读写集合
val list4 = ArrayList<Int>() // 通过构造函数创建也可以
// 下面同理
// set
val set1 = setOf<Int>()
val set2 = mutableSetOf<Int>()
val set3 = hashSetOf<Int>()
// map
val map1 = mapOf<String,Int>()
val map2 = mutableMapOf<String,Int>()
val map3 = hashMapOf<String,Int>()

集合的操作符

条件判断

val list = listOf(1,2,3,4,5,6)
// 任何一个满足,返回true
list.any {
    it >= 0
}
// 全部满足,返回true
list.all {
    it >= 0
}
// 没有一个满足,返回true
list.none{
    it < 0
}
// 满足条件的个数
list.count{
    it >= 0
}

集合运算

求和

// 所有元素求和
list.sum()
// 对每个元素的lambda表达式求和
list.sumBy {
    it % 2
}

遍历每个元素,求经过lambda表达式运算后的值

// 参数initValue是初始值
// element当前遍历的元素,从第一个开始
// currentValue当前计算后的值
list.fold(initValue) {currentValue,element -> 
    currentValue + element / 2}
// 反方向遍历
list.foldRight(initValue) {currentValue,element ->
    currentValue + element / 2}
// 不带初始值,currentValue是第一个元素,element从第二个开始
list.reduce{currentValue,element ->
    currentValue + element / 2}
// 反方向遍历,currentValue是最后一个元素,element从倒数第二个开始
list.reduceRight{currentValue,element ->
    currentValue + element / 2}

遍历

// 无索引强循环
list.forEach{
    print(it)
}
// 带索引循环
list.forEachIndexed{index, value -> 
    print("position $index is $value")}
// 包括11，但不包括66
for (i in 11 until 66) { ... }
// 每次递增4
for (i in 23..89 step 4) { ... }
// downTo递减
for (i in 50 downTo 7) { ... }

最大最小值

// 返回最大值
list.max()
// 返回lambda运算后的最大值
list.maxBy{it}
// 返回最小值
list.min()
// 返回lambda运算后的最小值
list.minBy{it}

过滤操作

// 删除前n个元素返回
list.drop(n)
// 删除后n个元素返回
list.dropLast(n)
// 删除满足条件的第一个元素返回
list.dropWhile {
    it > 3
}
// 删除满足条件的最后一个元素返回
list.dropLastWhile {
    it > 3
}

// 过滤所有满足条件的元素返回
list.filter {
    it > 3
}
// 过滤所有不满足条件的元素返回
list.filterNot {
    it > 3
}
// 过滤所有非空元素返回
list.filterNotNull()
// 过滤指定索引集合对应的元素
list.slice(listof(0,1,2))

映射

// 遍历每个元素,依次经过lambda运算,最终返回新的list
list.map{
    it * 2
}
// 同上,带下标的遍历
list.mapIndexed {index, it -> index * it}
// 同上,过滤非空值
list.mapNotNull { it * 2 }
// 遍历每个元素,将返回的每个list合并,最终返回合并后的list
list.flatMap {
    listOf(it, it + 1)
}
// 根据key分组,返回一个map
list.groupBy {
    if (it % 2 == 0) "even" else "odd"
}
// 将返回的结果list放入一个指定的list
val resultList = mutableListOf<Int>()
list.mapTo (resultList) {
    it * 2
}

集合取值

// 取前面的n个元素返回
list.take(n)
// 取后面的n个元素返回
list.takeLast(n)
// 取满足条件的第一个元素返回
list.takeWhile {
    it > 3
}
// 取满足条件的最后一个元素返回
list.takeLastWhile {
    it > 3
}
// 返回下标为n的元素
list.elementAt(n)
// 返回下标为n的元素,越界返回null
list.elementAtOrNull(n)
// 返回下标为n的元素,越界返回经过lambda运算后的值
list.elementAtOrElse(n) { index -> index * 2}
// 返回第一个元素
list.first()
// 返回满足条件的第一个元素
list.first { it > 1}
// 返回第一个元素,如果集合为空返回null
list.firstOrNull()
// 返回满足条件的第一个元素,没有满足的返回null
list.firstOrNull { it > 1 }
// 返回最后一个元素
list.last()
// 返回满足条件的最后一个元素
list.last { it > 1}
// 返回最后一个元素,如果集合为空返回null
list.lastOrNull()
// 返回最后一个元素,没有满足的返回null
list.lastOrNull { it > 1 }
// 返回第一个出现的元素2的索引
list.indexOf(2)
// 返回最后一个出现的元素2的索引
list.lastIndexOf(2)
// 返回满足条件的第一个元素索引
list.indexOfFirst {
    it > 2
}
// 返回满足条件的最后一个元素索引
list.indexOfLast {
    it > 2
}
// 返回满足条件的唯一元素,如果有多个,或不存在满足条件的则抛异常
list.single {
    it == 5
}
// 返回满足条件的唯一元素,如果有多个,或不存在满足条件的则返回null
list.singleOrNull {
    it == 5
}

拼接和切割

val list1 = listOf(1,2,3,4,5)
val list2 = listOf(6,7,8,9,10)
//拼接
list1 + list2 = list1.plus(list2)
//按条件切割成两个list
val(list3, list4) = list1.partition {
    it % 2 == 0
}
// 合并,返回一个由pair组成的list,每一个pair是取两个list下标相同的两个元素
val pairList: List<Pair<Int,Int>> = list1.zip(list2)
// 将一个由pair组成的list切割成两个list,再返回
val (list5, list6) = pairList.unzip()

排序和逆序

val list = listOf(1,2,3,4,5,6)
// 逆序
list.reversed()
// 升序
list.sorted()
// 根据lambda表达式返回值来升序排序
list.sortedBy {
    it * 2
}
// 降序
list.sortedDescending()
// 根据lambda表达式返回值来降序排序
list.sortedByDescending {
    it * 2
}