    fun listTest() {
        //只读
        var list = listOf("huahua","wangwang","jun")
        println(list.getOrElse(2) { "UnKnown" })
        println(list.getOrNull(2) ?: "UnKnown")
        var list2 = list.toMutableList();
        list2.remove("huahua")
        println(list)
        println(list2)

        //可写
        val mutableList = mutableListOf<String>("jack", "hua", "wang")
        println(mutableList.add("jun"))
        println(mutableList.remove("jack"))
        println(mutableList)
    }

运行结果：jun
                jun
                [huahua, wangwang, jun]
                [wangwang, jun]
                true
                true
                [hua, wang, jun]

1.2.mutator函数

能修改可变列表的函数统一名称为：mutator函数。与java不同的是kotlin可以使用+=、-=直接操作list，来实现增加、删除元素。可以基于lambda表达式指定条件删除元素:removeIf

    fun mutatorTest() {
        //能修改可变列表的函数统一名称：mutator函数
        val mutableList = mutableListOf<String>("jack", "hua", "wang")
        mutableList += "cheng"
        mutableList -= "hua"
        mutableList.removeIf {
            it.contains("wang")
        }
        println(mutableList)
    }

运行结果：[jack, cheng]

1.3.集合遍历

for in遍历一个参数：item

forEach遍历一个参数：item

forEachIndexed遍历两个参数：1.index 2.item

    fun forListTest() {
        val mutableList = mutableListOf<String>("jack", "hua", "wang")
        for(s in mutableList) {
            print("${s},")
        }
        println()
        mutableList.forEach{
            print("${it},")
        }
        println()
        mutableList.forEachIndexed { index, s ->
            print("${index}:${s},")
        }
    }

运行结果：jack,hua,wang,
jack,hua,wang,
0:jack,1:hua,2:wang,

1.4.结构

    fun jiegouTest() {
        val (origin, _, dest) = mutableListOf("jack", "hua", "wang")
    }

_下划线表示不要此变量，就不会去声明了。字节码中可以看到：

   public final void jiegouTest() {
      List var3 = CollectionsKt.mutableListOf(new String[]{"jack", "hua", "wang"});
      boolean var5 = false;
      String var1 = (String)var3.get(0);
      var5 = false;
      String dest = (String)var3.get(2);
   }

其中没有对下划线进行一个初始化和声明

2.Set

和list相似。不同点java和kotlin相同，set无法有相同元素，list可以有相同元素。

和list相似的方法就不多说了如：setOf、mutableSetOf和mutator等等函数。

    fun setTest() {
        //只读
        val set1 = setOf<String>("jack","wang","hua")
        println(set1)
        //可写
        val set2 = mutableSetOf<String>("jack","jun","wang")
        set2 += "hua"
        set2 -= "jack"
        println(set2)
    }

运行结果： [jack, wang, hua]
[jun, wang, hua]

2.1.List和Set转换

list.toSet()转换成Set，同时去除重复元素

set.toList()转换成list

有时我们就是想要List，只是想要去除重复而已。初学者的我想到的是list.toSet().toList()，笑死了，这样太不好看了，kotlin有一个list.distinct()函数，去除重复。相信会数据库的小伙伴，知道distinct的含义了。

    fun list2set() {
        val mutableListOf = mutableListOf<String>("jack", "jack", "hua")
        println("mutableListOf: $mutableListOf")
        println("mutableListOf to set: ${mutableListOf.toSet()}")
        println("mutableListOf distinct: ${mutableListOf.distinct()}")
    }

运行结果：mutableListOf: [jack, jack, hua]
mutableListOf to set: [jack, hua]
mutableListOf distinct: [jack, hua]

3.Map

3.1.Map的创建

mapOf、mutableMapOf 有了上边的例子大家应该就知道它俩的作用了，前者是可读，后者是可写。

mapOf("jack" to 20, "hua" to 10)

to看上去是关键字，但事实上是省略了点号和参数的特殊函数，to将它左边和右边的值转换成一对Pair，看到下边的例子，你就能理解了。

mapOf(Pair("jack", 20), Pair("hua", 10))

这两者是相同的

3.2.读取Map的值

[]:读取键对应的值

getValue:读取键对应的值，不存在抛出异常

getOrElse:读取键对应的值，不存在使用匿名函数返回的默认值

getOrDefault:读取键对应的值，不存在返回默认值

    fun getMapValue() {
        val mapOf1 = mapOf("jack" to 28, "hua" to 24, "wang" to 24)
        println("[]: ${mapOf1["jack"]}")
        println("getValue : ${mapOf1.getValue("hua")}")
        println("getOrElse : ${mapOf1.getOrElse("jun"){"Unknown"}}")
        println("getOrDefault : ${mapOf1.getOrDefault("cheng", "lala")}")
    }

运行结果： []: 28
                getValue : 24
                getOrElse : Unknown
                getOrDefault : lala

3.3.map遍历

    fun forEachMap() {
        val mapOf1 = mapOf("jack" to 28, "hua" to 24, "jun" to 23)
        mapOf1.forEach{
            print("${it.key}:${it.value}|")
        }
        println()
        mapOf1.forEach { (key, value) ->
            print("${key}:${value}|")
        }
    }

运行结果：jack:28|hua:24|jun:23|
jack:28|hua:24|jun:23|

两个foreach在于，我们有没有给其变量名，没有给编译器给我们提供了it表示当前项。

3.4.可变集合、mutator、getOrPut

可变集合用mutableMapOf前面说过了，mutator函数对于map来讲也是可以使用操作的，其中getOrPut说一说：它也是获取当前键对应的值，但是如果所get的键不存在就添加进map中。

    fun mutableMapTest() {
        val mapOf1 = mutableMapOf("jack" to 28, "hua" to 24, "wang" to 24)
        mapOf1 += "cheng" to 28
        mapOf1 -= "hua"
        mapOf1.put("zhang", 31)
        println(mapOf1)
        mapOf1.getOrPut("li", {90})
        println(mapOf1)
    }

运行结果：{jack=28, wang=24, cheng=28, zhang=31}
{jack=28, wang=24, cheng=28, zhang=31, li=90}