[移动开发]Kotlin系列之List、Set、Map详解

集合：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}")
}