集合:List
Kotlin 的List分为可变的和不可变的两种
创建
listOf():该函数返回不可变的List集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
var list: List<Int> = listOf(null,2)
listOfNotNull():该函数返回不可变的List集合。该函数与前一个函数的唯一区别是,该函数会自动去掉传入的一系列参数中的null值。
var list: List<Int> = listOfNotNull(null, 2) //自动去除了null
mutableListOf():该函数返回可变的MutableList集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
var list: MutableList<Int> = mutableListOf()
arrayListOf():该函数返回可变的ArrayList集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
var list: ArrayList<Int> = arrayListOf()
转换
toMutableList()转换函数
如果已经有了一个不可变的List,想把他转换成可变的List,可直接调用转换函数toMutableList()
// 不可变集合
val mList: List<Int> = listOf(1, 3, 5, 7, 9)
// 调用toMutableList()函数进行转换
val mMutableList = mList.toMutableList()
// 调用可变函数的add()方法
mMutableList.add(11)
// 打印输出
println(mMutableList)
toList()转换函数
如果已经有了一个可变的List,想把他转换成不可变的List,可直接调用转换函数toList()
//可变集合
var mMutableList: MutableList<Int> = mutableListOf()
//添加元素
mMutableList.add(1)
//变成不可变List
var list: List<Int> = mMutableList.toList()
安全函数
kotlin还提供了安全索引取值函数,使用它们就不会下标溢出了
getOrElse:如果不存在,则返回lambda结果
list.getOrElse(5) { "empty" } //如果index为5点位置为空时,执行后面lambda
getOrNull:如果不存在,返回null
(list.getOrNull(10) ?: "is null"
elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
//下标越界会将defaultValue返回。
elementAtOrNull(index: Int): T?下标
//越界返回null
firstOrNull(predicate: (T) -> Boolean): T?
//返回符合条件的第一个元素,没有就返null
类似于这种的空安全函数还有很多,在使用我们Kotlin中的List时,最好要使用这种空函数,一是为了安全,二是为了代码更简洁
遍历集合
for in循环
同正常的java中的for循环
for (item in mutableList) {println(item)}
forEach
it指带mutableList
mutableList.forEach { println(it) }
forEachIndexed
遍历时获取Index索引
mutableList.forEachIndexed { index, s ->println("$index $s")}
删除
遍历集合mutableListOf,将removeIf表达式中为true的元素删除。
it指代mutableListOf中便利的元素。意思为把含有“D”的元素删除
mutableListOf.removeIf{ it.contains("D")}
解构
之前我们提到过,kotlin允许在一个表达式中给多个变量赋值 可以用"_"过滤不想要的元素
fun main() {//调用mutableListOf创建可变list
val mutableList = mutableListOf("张三", "李四", "王五")
val (a, _, c) = mutableList
}
集合:Set
Kotlin的集合分为两大类:可变集合和不可变集合。只有可变集合才能添加、删除、修改元素,不可变集合只能读取元素。
Kotlin的Collection集合和Set集合的功能基本相同,Set集合只是为Collection集合增加了额外的限制:集合元素不允许重复。
创建
setOf():该函数返回不可变的Set集合。该函数可以接受0个或多个参数,这些参数将作为集合的元素。
val of: Set<Int> = setOf<Int>(1, 2, 3)
mutableSetOf():该函数返回可变的MutableSet集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
val of1: MutableSet<Int> = mutableSetOf<Int>(1, 2, 3)
hashSetOf():该函数返回可变的HashSet集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
val hashSetOf: HashSet<Int> = hashSetOf<Int>()
linkedSetOf():该函数返回可变的LinkedHashSet集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
val linkedSetOf: LinkedHashSet<Int> = linkedSetOf<Int>()
sortedSetOf():该函数返回可变的TreeSet集合。该函数可接受0个或多个参数,这些参数将作为集合的元素。
val treeSet: TreeSet<Int> = sortedSetOf<Int>()
转换
不可变转换成可变函数
val of: Set<Int> = setOf<Int>(1, 2, 3)
of.toMutableSet()
可变转换成不可变函数
val of1: MutableSet<Int> = mutableSetOf<Int>()
of1 += 1
of1 += 2
of1 += 3
val toSet = of1.toSet()
去重
list 与 set 互转达到去重效果
//第一种写法
val list = listOf(1, 2, 3, 4, 4).toSet().toList()
//[1, 2, 3, 4]
print(list)
//第二种写法
//输出[1, 2, 3, 4]
print(listOf(1, 2, 3, 4, 4).distinct())
两种写法的没区别可以看下distinct()的源码
public fun <T> Iterable<T>.distinct(): List<T> {
return this.toMutableSet().toList()
}
删除
remove(element:E):删除指定元素,删除成功则返回true。
removeAll(elements:Collection):批量删除Set集合中的多个元素。
retainAll(elements:Collection):只保留Set集合中与elements集合共有的元素。
clear():清空集合。
//定义一个可变的Set
var languages = mutableSetOf("Java", "OC", "PHP", "Perl", "Ruby", "Go")
//删除"PHP"
languages.remove("PHP")
//批量删除多个元素
languages.removeAll(setOf("Ruby", "Go"))
//清空Set集合
languages.clear()
集合:Map
创建
mapOf():该函数返回不可变的 Map 集合
val map: Map<String, Int> = mapOf<String, Int>("Java" to 86, "Kotlin" to 92, "Go" to 78)
mutableMapOf():该函数返回可变的 MutableMap 集合
val map1: MutableMap<String, Int> = mutableMapOf<String, Int>("Java" to 86, "Kotlin" to 92)
map1["Go"] = 78 //put("Go", 78)
hashMapOf():该函数返回可变的 HashMap 集合
val map2: HashMap<String, Int> = hashMapOf<String, Int>("Java" to 86, "Kotlin" to 92)
map2["Go"] = 78 //put("Go", 78)
linkedMapOf():函数返回可变的 LinkedHashMap 集合
val map3: LinkedHashMap<String, Int> = linkedMapOf<String, Int>("Java" to 86, "Kotlin" to 92)
map2["Go"] = 78 //put("Go", 78)
sortedMapOf():该函数返回可变的 TreeMap 集合
val map4: SortedMap<String, Int> = sortedMapOf<String, Int>("Java" to 86, "Kotlin" to 92)
map2["Go"] = 78 //put("Go", 78)
转换
将不可变map转换成可变map
val map: Map<String, Int> = mapOf<String, Int>("Java" to 86, "Kotlin" to 92, "Go" to 78)
val toMutableMap = map.toMutableMap()
toMutableMap["Go"] = 78
将可变map转换成不可变map
val map1: MutableMap<String, Int> = mutableMapOf<String, Int>("Java" to 86, "Kotlin" to 92)
val toMap = map1.toMap()
常用方法
getOrDefault:
我们可以设置没有拿到元素时的默认值,getOrDefault如果有就会拿到
map1.getOrDefault("Tony2", -1)
//如果map1中没有Tony2,那么将返回给我们默认的-1
getOrElse:
还可以使用来设置没有拿到数据的时候返回的整型数据
map1.getOrElse("Tony1") { -1 }
//如果map1中没有Tony2,那么将返回给我们-1
getOrPut:
使用getorput,如果map中含有该key将会直接返回value,没有则创建
map2.getOrPut("fff"){555}
其余常用方法:
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 76)
// map.all 如果所有的元素都满足给定的条件,则返回 true
println(map.all { it.key.length > 4 && it.value > 80 }) //false
// map.any 如果至少有一个元素满足给定的条件,则返回 true
println(map.any { it.key.length > 4 && it.value > 80 }) //true
// 将 Map 集合中的元素映射成一个新的 List 集合
val mappedList = map.map { "语言名称:${it.key} 价格:${it.value}" }
// 获取 Map 集合中的最大元素,根据 key
println(map.maxBy { it.key }) //Kotlin=92
// 获取 Map 集合中的最小元素,根据 key
println(map.minBy { it.key }) //Go=76
val bMap = mapOf("Swift" to 67, "JavaScript" to 80, "Kotlin" to 92)
// Map 集合相加,相当于并集(由于 Map 提供了 operate 修饰的 plus 方法,因此可以使用 "+" 运算符操作集合)
println(map + bMap) //{Java=86, Kotlin=92, Go=76, Swift=67, JavaScript=80}
// Map 集合相减,减去他们的公共元素(由于 Map 提供了 operate 修饰的 minus 方法,因此可以使用 "-" 运算符操作集合)
println(map - bMap) //{Java=86, Kotlin=92, Go=76}
// 对 Map 集合中的元素进行过滤,key 中包含 "o" 的元素
val filteredMap = map.filter { "o" in it.key }
遍历
for (entry in map.entries) { … } for-in 遍历,遍历的是 Entry
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
// for-in 遍历,遍历的是 Entry
for (en in map.entries) {
println("${en.key}: ${en.value}")
}
for (key in map.keys) { … } 遍历 key,再通过 key 获取 value
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
// for-in 遍历,遍历的是 key
for (key in map.keys) {
println("$key: ${map[key]}")
}
for ((key, value) in map) { … } for-in 遍历
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
// for-in 遍历
for ((key, value) in map) {
println("$key: $value")
}
map.forEach { … } forEach Lambda 表达式遍历
val map = mapOf("Java" to 86, "Kotlin" to 92, "Go" to 78)
// forEach Lambda 表达式遍历
map.forEach {
println("${it.key}: ${it.value}")
}