Kotlin集合类
-
Kotlin从入门进阶到实战
-
Kotlin是在java类库基础上进行了改造和扩展，引入了不可变集合类，同时扩展了大量方便实用的功能，这些功能api都在kotlin.collections包下。
-
在kotlin集合类中不仅能支持普通对象，而且能够持有函数类型的变量。
val funList: List<(Int) -> Boolean> = listOf({ it -> it % 2 == 0 }, { it -> it % 2 == 1 })
fun test() {
val list = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
val result = list.filter(funList[0])
val result1 = list.filter(funList[1])
println(result)
println(result1)
}
这就是面向对象式和函数式编程混合开发的样子
Kotlin集合类概述
- Kotlin集合类可以分为：可变集合类（Mutable）和不可变集合类（Immutable）。
- 常用的集合类主要有三种：List（列表）、Set（集）和Map（映射）
- List容器中的元素以线性方式存储，集合中可以存放重复对象。列表中的数据是有序排列
- Set集容器的元素无序、不重复。
- Map映射的持有的是 键值对 对象每一个对象都包含一堆 K-V对象。Map存储的容器中每一个对象都有一个Key对象，Key决定对象在容器中的位置。关键字Key是唯一的。关键字本身并不能决定对象的存储位置，它通过散列产生一个 散列码 的整数值，这个散列码对应值Value的存储位置。
- 如果从数据结构本身来看List中的下标就是Key，只不过key是有序的Int类型，所以说List也可以成为特殊的Map数据结构。而Set也是Key为Int值，但是Value不能重复。.
Kotlin集合类继承层次
- Iterable 父类任何类继承这个接口就表示可以遍历序列元素
- MutableIteIterable 在迭代器期间支持删除元素的迭代
- Collocation List和Set的父类接口，只可读不可变
- MutableCollection 支持添加和删除元素的Collection。它提供了写入的函数，如add、remove或clear等
- List 最常用的集合，继承Collection接口，元素有序，只读不可变
- MutableList 继承List，之处添加和删除元素，除了拥有List中读取的函数，还有add、remove或clear等写入数据的函数
- Set 元素无重复、无序。继承Collection接口。只读不可变
- MutableSet 继承Set，支持添加和删除元素Set
- Map 存储K-V对的集合，在Map映射表中Key是唯一的。
- MutableMap 支持添加和删除元素的Map
不可变集合类
- List列表分为只读不可变的List和可变MutableList。List列表的类型层次结构如下
- Set集合也分为不可变Set和可变MutableSet。Set集合类的类型层次如下
- Kotlin中Map和Set一样分为 只读Map和可变MutableMap。Map没有继承Collection接口。
创建集合类
-
Kotlin中分别用 listOf()、setOf()、mapOf() 创建不可变的容器，使用mutableListOf() 、mutableSetOf() 、mutableMapOf() 创建可变的Mutable容器
-
代码示例如下
val list = listOf(1, 2, 3, 4, 5)//创建不可变List
val mutableList = mutableListOf(1, 2, 3, 4, 5)//创建可变mutableList
val set = setOf(1,2,3,4,5)//创建不可变Set
val mutableSet = mutableSetOf(1,2,3,4,5)//创建可变mutableSet
val map = mapOf(1 to "A" , 2 to "B" ,3 to "C")//创建不可变Map
val mutableMap = mutableMapOf(1 to "A" , 2 to "B" ,3 to "C")//创建可变mutableMap
- 如果创建没有元素的空List使用ListOf()即可。不过需要显式指定变量的类型。否则会报错
Type inference failed: Not enough information to infer parameter T in inline fun listOf( ): List Please specify it explicitly.
val list = listOf()
val set = setOf()
val map = mapOf()
遍历集合中的元素
- List、Set集合继承了Iterable接口，里面扩展了forEach函数来迭代遍历元素。同样Map接口也扩展了forEach函数迭代遍历元素。
val list = listOf(1, 2, 3, 4, 5, 6)
list.forEach { println(it) }
val set = setOf("A", "B", "C")
set.forEach { println(it) }
val map = mapOf(1 to "o", 2 to "p", 3 to "q")
map.forEach { println("key = ${it.key} value = ${it.value}") }
在Iterable和Map中，forEach函数都是一个内联inline函数。另外如果我们想在迭代器遍历的时候获取index下标，在List和Set中可以使用下面的forEachIndexed函数
val list = listOf(1, 2, 3, 4, 5, 6)
//第一个参数是index 第二个参数 i 是value
list.forEachIndexed { index, i -> println("index = ${index} value = ${i}") }
val set = setOf("A", "B", "C")
set.forEachIndexed { index, s -> println("index = ${index} value = ${s}") }
Map的元素是Entry类型，有entries属性持有
public val entries: Set>
这个Entry类型定义如下
public interface Entry {
/**
* Returns the key of this key/value pair.
*/
public val key: K
/**
* Returns the value of this key/value pair.
*/
public val value: V
}
可以通过Entry属性获取Map所有键值对的Set
val map = mapOf(1 to "o", 2 to "p", 3 to "q")
map.entries.forEach { println("key = ${it.key} , value = ${it.value}") }
key = 1 , value = o
key = 2 , value = p
key = 3 , value = q
映射函数
- 使用map函数，可以把集合中的元素依次使用给定的转换函数进行映射操作，元素映射之后的新值会存入一个新的集合中，并且返回这个新集合。
- 在List、Set继承的Iterable接口和Map接口中，都提供了这个map函数。使用map的代码示例如下：
val list = listOf(1, 2, 3, 4, 5, 6)
val mapForList = list.map { it * it }// map函数对每个元素进行乘方操作
println(mapForList)
//输出结果如下
[1, 4, 9, 16, 25, 36]
val set = setOf("A", "B", "C")
val mapForSet = set.map { it + "helloMap" }//map函数对每个元素进行字符串拼接
println(mapForSet)
//输出结果如下
[AhelloMap, BhelloMap, ChelloMap]
val map = mapOf(1 to "o", 2 to "p", 3 to "q")
val mapForMap = map.map { it.value + "Map" }
println(mapForMap)
//输出结果如下
[oMap, pMap, qMap]
map函数如下：
public inline fun Iterable.map(transform: (T) -> R): List {
return mapTo(ArrayList(collectionSizeOrDefault(10)), transform)
}
这里的R类型是映射之后的数据类型，我们也可以传入一个List
val list = listOf(1, 2, 3, 4, 5, 6)
val mapFList = list.map { it -> listOf(it + 100, it + 1000, it + 10000) }
println(mapFList)
输出结果如下，每个元素映射为一个List，这个List中有三个元素 分别为 it + 100 it+1000 it+10000 ，这个时候返回值会是List套一个List
[[101, 1001, 10001], [102, 1002, 10002], [103, 1003, 10003], [104, 1004, 10004], [105, 1005, 10005], [106, 1006, 10006]]
Kotlin中还提供了一个flattern函数，效果是使结构变为一层还是上边的代码
val list = listOf(1, 2, 3, 4, 5, 6)
val mapFList = list.map { it -> listOf(it + 100, it + 1000, it + 10000) }.flatten()
println(mapFList)
输出如下
[101, 1001, 10001, 102, 1002, 10002, 103, 1003, 10003, 104, 1004, 10004, 105, 1005, 10005, 106, 1006, 10006]
flatMap函数是map和flat两个函数的复合逻辑，代码如下
val list = listOf(1, 2, 3, 4, 5, 6)
val mapFList = list.flatMap { it -> listOf(it + 1, it + 2) }
println(mapFList)
输出结果如下
[2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8]
过滤函数
- 使用filter()函数，下面是代码示例
data class Student(var name: String, var age: Int, var score: Int) {
override fun toString(): String {
return "$name ${age}岁 ${score}分"
}
}
@JvmStatic
fun main(args: Array) {
val list = listOf(Student("张三", 18, 80)
, Student("小明", 16, 70)
, Student("小李", 16, 50)
, Student("小王", 20, 100)
, Student("小陆", 18, 59))
val filter = list.filter { it.score < 60 }
println(filter)
}
如果想找到成绩不及格的学生。使用 list.filter { it.score < 60 }
[小李 16岁 50分, 小陆 18岁 59分]
如果查看年龄>= 18岁的
val filter = list.filter { it.age >= 18 }
//输出结果如下
//[张三 18岁 80分, 小王 20岁 100分, 小陆 18岁 59分]
- 如果想通过下标来过滤，可以用filterIndexed
val filter = list.filterIndexed { index, student -> index % 2 == 0 && student.score > 55}
//输出 [张三 18岁 80分, 小陆 18岁 59分]
val filter = list.filterIndexed { index, student -> index % 2 == 0 && index > 3 }
//输出 [小陆 18岁 59分]
filterIndexed()函数如下
public inline fun Iterable.filterIndexed(predicate: (index: Int, T) -> Boolean): List {
return filterIndexedTo(ArrayList(), predicate)
}
排序函数
- Kotlin集合类的提供了倒叙排序的集合元素的函数reversed(),示例如下
@JvmStatic
fun main(args: Array) {
val list = listOf(1, 2, 3)
val set = setOf(4, 5, 6)
println(list.reversed())
println(set.reversed())
}
打印输出如下
[3, 2, 1]
[6, 5, 4]
这个Iterable的扩展函数reversed()是直接调用的java.util.Collections.reverse()
public fun Iterable.reversed(): List {
if (this is Collection && size <= 1) return toList()
val list = toMutableList()
list.reverse()//调用java中List类型的reverse()方法
return list
}
- 升序排列是用sorted()
@JvmStatic
fun main(args: Array) {
val list = mutableListOf(3, 2, 1)
val set = setOf(6, 5, 4)
println(list.sorted())
println(set.sorted())
}
输出如下
[1, 2, 3]
[4, 5, 6]
sorted()也是直接调用了java api来实现的
public fun > Iterable.sorted(): List {
if (this is Collection) {
if (size <= 1) return this.toList()
@Suppress("UNCHECKED_CAST")
return (toTypedArray>() as Array).apply { sort() }.asList()
}
return toMutableList().apply { sort() }
}
最终调用java.util.Arrays.sort()
public actual fun > MutableList.sort(): Unit {
if (size > 1) java.util.Collections.sort(this)
}
元素去重
- distinct()
@JvmStatic
fun main(args: Array) {
val list = listOf(1, 2, 3, 4, 2, 5, 6, 4, 3, 5, 3, 1, 9)
println(list.distinct())
}
打印输出
[1, 2, 3, 4, 5, 6, 9]
data class Student(var name: String, var age: Int, var score: Int) {
override fun toString(): String {
return "$name ${age}岁 ${score}分"
}
}
@JvmStatic
fun main(args: Array) {
val list = listOf(Student("张", 10, 100)
, Student("张", 10, 100)
, Student("李", 20, 90))
println(list.distinct())
}
输出结果如下
[张 10岁 100分, 李 20岁 90分]