List集合
与 Java类似，List集合的最大特征就是集合元素都有对应的顺序索引 List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引，例如第一次添加的元素索引为0，第二次添加的元素索引为 1...
声明和创建 List集合
Kotlin 同样并未真正实现 List 集合，它只是通过别名借用了Java体 系中的 ArrayList集合 。因此不推荐通过构造器来创建 List集合，而是推荐使用工具函数来创建List集合。 Kotlin提供了如下工具函数来创建 List集合。
- listOf(): 该函数返回不可变的 List集合。该函数可接受 0个或多个参数，这些参数将作为集合的元素。
- listOfNotNull(): 该函数返回不可变的 List 集合。该函数与前一个函数的唯一区别是，该函数会自动去掉传入的一系列参数中的 null值。
- mutablelistOf():该函数返回可变的 MutableList集合。该函数可接受 0个或多个参数，这些参数将作为集合的元素。
- arraylistOf(): 该函数返回可变的 ArrayList集合。该函数可接受 0个或多个参数，这些参数将作为集合的元素。
如下程序示范了使用工具函数创建 List集合 。
fun main(args: Array<String>) {
//创建不可变集合 ， 返回值是 List
var list1 = listOf("java","c","c#","kotlin",null)
println(list1) //集合包含 null 值
//创建不可变集合，返回值是 List
var list2 = listOfNotNull("java","c","c#","kotlin",null)
println(list2) //集合不包含 null 值
//创建可变集合，返回值是 List
var list3 = mutableListOf("java","c","c#","kotlin",null)
println(list3)
println("listOf 的返回对象的实际类型 ${list1.javaClass}")
println("listOfNotNull 的返回对象的实际类型 ${list2.javaClass}")
println("mutableListOf 的返回对象的实际类型 ${list3.javaClass}")
//创建 ArrayList 集合
var list4 = arrayListOf("java","c","c#","kotlin",null)
println(list4)
}
使用List的方法
fun main(args: Array<String>) {
//创建不可变集合 ， 返回值是 List
var list1 = listOf("java", "c", "c#", "kotlin", null)
for (i in list1.indices) {
//使用门运算符访问集合元素，实际上就是根据 get 方法访问
println(list1[i])
}
//获取指定元素的出现位置
println(list1.indexOf("kotlin"))
//获取 List 的子集合
println(list1.subList(1, 3))
}
可变的List
使用 mutableListOf()、 arrayListof()函数返回的 List集合都是可变的， 其中后面一个函数返回的集合类型都是明确的ArrayList。
fun main(args: Array<String>) {
//创建可变集合，返回值是 List
var list1 = mutableListOf("java", "c", "c#", "kotlin", null)
//在索寻1 2 处插入一个新元素
list1.add(2,"ccc")
//删除索引 1 处的元素
list1.removeAt(1)
//将索引 1 处的元素替换为”Lua”
list1[1] = "Lua"
println(list1)
//清空集合
list1.clear()
}
Map集合
与 Java相同的是， Kotlin 的Map集合同样用于保存 key-value对; 与 Java不同的是，Kotlin的 Map 集合也被分为可变的和不可变的。
声明和创建 Map 集合
Kotlin 并没有真正为JVM 平台实现任何 Map 集合类(只是通过别名借用了 Java集合框架的类)，因此不推荐通过构造器创建 Map 集合，而是推荐使用 Kotlin 提供的工具函数来创建 Map集合。
Kotiin 提供了如下函数来创建 Map 集合 。
- mapOf(): 该函数返回不可变的 Map 集合。该函数可接受 0 个或多个 key-value 对，这些 key-value对将作为 Map 的元素。
- mutableMapOf(): 该函数返回可变的 MutableMap 集合。该函数可接受 0 个或多个key-value对，这些 key-value对将作为集合的元素。
- hashMapOf(): 该函数返回可变的 HashMap集合。该函数可接受 0个或多个key-value对，这些 key-value 对将作为 Map 的元素。
- linkedMapOf():该函数返回可变的 LinkedHashMap 集合 。该函数可接受 0 个或多个 key-value 对，这些 key-value 对将作为 Map 的元素 。
- sortedMapOf():该函数返回可变的 TreeMap 集合 。该函数可接受 0 个或多个key-value对，这些 key-value对将作为 Map 的元素。
如下程序示范了使用工具函数创建 Map 集合。
fun main(args: Array<String>) {
//创建不可变集合
var map1 = mapOf<String,Int>("java" to 86,"c" to 44,"kotlin" to 75)
// key-value 对按添加顺序排列
println(map1)
//创建可变集合
var map2 = mutableMapOf("java" to 86,"c" to 44,"kotlin" to 75)
// key-value 对按添加顺序排列
println(map2)
println("mapOf的返回对象的实际类型:${map1.javaClass}")
println("mutableMapOf的返回对象的实际类型:${map2.javaClass}")
//创建HashMap集合
var map3 = hashMapOf("java" to 86,"c" to 44,"kotlin" to 75)
//不保证 key-value 对的顺序
println(map3)
//创建 LinkedHashMap 集合
var map4 = linkedMapOf("java" to 86,"c" to 44,"kotlin" to 75)
// key-value 对按添加顺序排列
println(map4)
//创建 TreeMap 集合
var map5 = sortedMapOf("java" to 86,"c" to 44,"kotlin" to 75)
// key-value 对按 key 由小到大排列
println(map5)
}
从上面代码可以看出， Kotlin 需要使用 to 指定 key-value 对，其中 to 之前的是 key, to 之 后的是 value。
使用Map的方法
fun main(args: Array<String>) {
//创建不可变集合
var map1 = mapOf<String, Int>("java" to 86, "c" to 44, "kotlin" to 85)
//判断是否所有 key-value 对的 key 的长度都大于 4、 value 都大于 80
println(map1.all { it.key.length > 4 && it.value > 80 })
//判断是否任一key-value 对的 key 的长度都大于 4、 value 都大于 80
println(map1.any { it.key.length > 4 && it.value > 80 })
//由于有 contains ()方法，所以可用 in !in 运算符
println("java" in map1)
//对 Map 集合元素进行过滤:要求 key 包含 li
val filteredMap = map1.filter { "li" in it.key }
println(filteredMap)
//将每个 key-value 对映射成新值，返回所有新值组成的 Map 集合
val mappedList = map1.map { "${it.key} : ${it.value}" }
//[java : 86, c : 44, kotlin : 85]
println(mappedList)
//根据 key 获取最大值 kotlin=85
println(map1.maxBy { it.key })
//根据 key 获取最小值 c=44
println(map1.minBy { it.key })
var bMap = mapOf("Lua" to 67,"Erlang" to 73, "kotlin" to 85)
//集合相加，相当于并集
//{java=86, c=44, kotlin=85, Lua=67, Erlang=73, Kotlin=85}
println(map1+bMap)
//集合相减，减去它们公共的元素
//{java=86, c=44, kotlin=85}
println(map1-bMap)
}
遍历Map
Map 集合由多个 key-value 对组成，因此遍历 Map 集合时既可通过对 key-value 对进行遍历，也可先遍历 key，再通过 key 来获取对应的 value 进行遍历 。
Kotlin 的 Map 提供了operator修饰的 get()方法，因此可通过“[]”运算符根据 key来获取value。
此外， Map 也可直接用 for-in 循环进行遍历，这时循环变量的类型是 Entry (即 key-value对）。
下面程序示范了对 Map 集合的几种遍历方式。
fun main(args: Array<String>) {
//创建不可变集合
var map1 = mapOf<String, Int>("java" to 86, "c" to 44, "kotlin" to 85)
//遍历 Map 的 key-value 对， entris 元素返回 key-value 对组成的 Set
for(en in map1.entries){
println("${en.key} -> ${en.value}")
}
//先遍历 Map 的 key，再通过 key 获取 value
for (key in map1.keys){
println(map1[key])
}
//直接用 for-in 循环遍历 Map
for(map in map1){
println("${map.key} -> ${map.value}")
}
//用 Lambda 表达式遍历 Map
map1.forEach({
println("${it.key} -> ${it.value}")
})
}
可变的Map
除使用 mapOf()函数返回的集合是不可变集合之外，使用 mutableMapOf()、 hashMapOf()、linkedMapOf()、 sortedMapOf()函数返回的集合都是可变的，其中后面三个函数返回的集合类
型都是明确的，依次是 HashMap、 LinkedHashMap、 TreeMap。
创建可变的 Map 集合之后，接下来就可以对该 Map 的元素执行添加、删除、替换操作了 。 可变的 Map 为操作 key-value 对提供了如下方法。
clear(): 清空所有的 key-value对。
put(key: K, value: V): 放入 key-value 对。如果原来已有该 key，那么新放入的 value
会覆盖原有的 value。
putAll(from: Map<out K, V>):批量放入多个 key-value 对 。
remove(key: K):删除 key-value对。
此外， MutableMap 还提供了 一个 set(key, value)方法来放入 key-value 对，这意味着程序可
通过方括号“[]”运算符来放入 key-value 对。例如如下程序。
fun main(args: Array<String>) {
//创建可变集合
var map1 = mutableMapOf<String, Int>("java" to 86, "c" to 44, "kotlin" to 85)
//以方括号语法放入 key-value 对
map1["java"] = 9000
//用 put 方法放入 key-value 对
map1.put("c", 8600)
//{java=9000, c=8600, kotlin=85}
println(map1)
//删除 key 为 ”java”的 key-value 对
map1.remove("java")
println(map1)
println(map1.size)
//删除所有元素
map1.clear()
println(map1)
}
