List集合

与 Java类似，List集合的最大特征就是集合元素都有对应的顺序索引 List集合允许使用重复元素，可以通过索引来访问指定位置的集合元素。List集合默认按元素的添加顺序设置元素的索引，例如第一次添加的元素索引为0，第二次添加的元素索引为 1...

声明和创建 List集合

Kotlin 同样并未真正实现 List 集合，它只是通过别名借用了Java体 系中的 ArrayList集合 。因此不推荐通过构造器来创建 List集合，而是推荐使用工具函数来创建List集合。 Kotlin提供了如下工具函数来创建 List集合。

1. listOf(): 该函数返回不可变的 List集合。该函数可接受 0个或多个参数，这些参数将作为集合的元素。
2. listOfNotNull(): 该函数返回不可变的 List 集合。该函数与前一个函数的唯一区别是，该函数会自动去掉传入的一系列参数中的 null值。
3. mutablelistOf():该函数返回可变的 MutableList集合。该函数可接受 0个或多个参数，这些参数将作为集合的元素。
4. 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 集合 。

1. mapOf(): 该函数返回不可变的 Map 集合。该函数可接受 0 个或多个 key-value 对，这些 key-value对将作为 Map 的元素。
2. mutableMapOf(): 该函数返回可变的 MutableMap 集合。该函数可接受 0 个或多个key-value对，这些 key-value对将作为集合的元素。
3. hashMapOf(): 该函数返回可变的 HashMap集合。该函数可接受 0个或多个key-value对，这些 key-value 对将作为 Map 的元素。
4. linkedMapOf():该函数返回可变的 LinkedHashMap 集合 。该函数可接受 0 个或多个 key-value 对，这些 key-value 对将作为 Map 的元素 。
5. 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)
}