【文字内容源于《疯狂Kotlin讲义》，代码内容原创】
Kotlin 数组和集合（一）{创建数组、使用数组、使用for-in循环遍历数组、使用数组索引、多维数组}_kotlin 带索引遍历_桃子不出的博客-CSDN博客
目录
一、Set集合
1. 声明和创建Set集合
实际上 Kotlin 并没有真正为JVM平台实现任何 Set 集合类（只是通过别名借用了 Java集合框架的类），因此不推荐通过构造器创建 Set 集合，而是推荐使用 Kotlin 提供的工具函数来创建 Set 集合。
Kotlin 提供了如下函数来创建 Set 集合。
（1）setOf（）： 该函数返回不可变的 Set 集合。该函数可接受0个或多个参数，这些参数将
作为集合的元素。
//集合元素按添加顺序排列
val set = setOf<String>("apple", "orange", "banana", "bear")
println(set)（2） mutableSetOf（）： 该函数返回可变的 MutableSet 集合。该函数可接受0个或多个参数，
这些参数将作为集合的元素。
//集合元素按添加顺序排列
val mutableSet = mutableSetOf<String>("apple", "orange", "banana", "bear")
println(mutableSet)（3）hashSetOf（）： 该函数返回可变的 HashSet 集合。该函数可接受0个或多个参数，这些参数将作为集合的元素。
//不保证元素的顺序
val hashSet = hashSetOf<String>("apple", "orange", "banana", "bear")
println(hashSet)（4）linkedSetOf（）： 该函数返回可变的 LinkedHashSet 集合。该函数可接受0个或多个参数，
这些参数将作为集合的元素。
//集合元素按添加顺序排列
val linkedHashSet = linkedSetOf<String>("apple", "orange", "banana", "bear")
println(linkedHashSet)（5）soredSetOf（） ：该函数返回可变的 TreeSet 集合。该函数可接受0个或多个参数，这些
参数将作为集合的元素。
//集合元素由小到大排列
val sortedSet = sortedSetOf("apple", "orange", "banana", "bear")
println(sortedSet)运行结果：
[apple, orange, banana, bear]
[apple, orange, banana, bear]
[orange, banana, apple, bear]
[apple, orange, banana, bear]
[apple, banana, bear, orange]
2. 遍历Set
（1）Kotlin 也支持使用 for-in 循环遍历 Set ，与遍历数组的方式基本相同。
val seasons = setOf("春天", "夏天", "秋天", "冬天")
for (season in seasons) {
println(season)
}
运行结果：
春天
夏天
秋天
冬天从上面程序中可以看出，使用 for-in 循环遍历 Set 元素时无须获得 Set 元素的个数，也无须根据索引来访问 Set 元素， for-in 循环自动迭代 Set每个元素，当每个元素都被送代后， for-in 循环自动结束。
（2）Set 集合继承了 Iteratable ，因此可使用该接口中定义的 forEach（）方法来遍历集合。该方法需要接受 Lambda 表达式作为参数，该 Lambda 表达式负责对集合元素进行处理。
val seasons = setOf("春天", "夏天", "秋天", "冬天")
seasons.forEach {
println(it)
}
运行结果：
春天
夏天
秋天
冬天3. 可变的Set
除使用 setOf（）函数返回的集合是不可变集合之外，使用 mutableSetOf（）、 hashSetO（）、 linkedSetOf（）、 sortedSetOf（）函数返回的集合都是可变的，其中后面3个函数返回的集合类型都是明确的，依次是 HasSet，LinkedHashSet，TreeSet创建可变的 Set 集合之后，接下来就可以对该 Set 的元素执行添加、删除操作了。
（1）添加元素
val books = linkedSetOf<String>("《傲慢与偏见》", "《百年孤独》")
books.forEach {
println("before $it")
}
books.add("《红与黑》")
books.add("《绿野仙踪》")
println("------------------")
books.forEach {
println("after $it")
}
运行结果；
before 《傲慢与偏见》
before 《百年孤独》
------------------
after 《傲慢与偏见》
after 《百年孤独》
after 《红与黑》
after 《绿野仙踪》（2）删除元素
val stories = linkedSetOf<String>("《华胥引》", "《夏有乔木，雅望天堂》", "《长相思》", "《骄阳似火》")
stories.forEach {
println("before $it")
}
stories.remove("《华胥引》")
println("------------------")
stories.forEach {
println("after $it")
}
stories.removeAll(linkedSetOf("《夏有乔木，雅望天堂》", "《长相思》"))
println("------------------")
stories.forEach {
println("after $it")
}
stories.clear()
println("stories.size = ${stories.size}")
运行结果：
before 《华胥引》
before 《夏有乔木，雅望天堂》
before 《长相思》
before 《骄阳似火》
------------------
after 《夏有乔木，雅望天堂》
after 《长相思》
after 《骄阳似火》
------------------
after 《骄阳似火》
stories.size = 0二、List集合
1. 声明和创建List集合
Kotlin 提供了如下工具函数来创建 Lis 集合。
（1）listOf（）： 该函数返回不可变的List集合。该函数可接受0个或多个参数，这些参数将作为集合的元素。
val list1 = listOf<Int>(1, 2, 3)
println(list1)
运行结果 ：
[1, 2, 3]（2）listOfNotNull （）： 该函数返回不可变的 List 集合。该函数与前一个函数的唯一区别是，
该函数会自动去掉传入的一系列参数中的 null 值。简而言之，该函数返回的 List 集合不包含 ull 值。
val list2 = listOfNotNull("a", null, "b", "c")
println(list2)
运行结果：
[a, b, c]（3）mutablelistOf（）： 该函数返回可变的 utableList 集合。该函数可接受0个或多个参数，
这些参数将作为集合的元素。
val list3 = mutableListOf<Int>(11, 22, 33, 44)
println(list3)
运行结果：
[11, 22, 33, 44]（4）arraylistOf（）： 该函数返回可变的 ArrayList 集合。该函数可接受0个或多个参数，这
些参数将作为集合的元素。
val list4 = arrayListOf<String>("人类", "高质量", "码农")
println(list4)
运行结果：
[人类, 高质量, 码农]2. 使用 List 的方法
（1）get：带operator 修饰的方法，因此可用“［］“运算符访问集合元素
（2）indexOf：返回集合元素在List中的索引。
（3）lastlndexOf：返回集合元素在 List 中最后一次的出现位置。
（4）sublist：返回 List 集合的子集合。
val words = mutableListOf<String>("a", "2", "ee", "a", "bcd")
println("words[2] = ${words[1]}")
println("words.indexOf(\"ee\") = ${words.indexOf("ee")}")
println("words.lastIndexOf(\"a\") = ${words.lastIndexOf("a")}")
println("words.subList(2,4) = ${words.subList(2, 4)}")
运行结果：
words[2] = 2
words.indexOf("ee") = 2
words.lastIndexOf("a") = 3
words.subList(2,4) = [ee, a]3. 可变的List
使用 mutableListOf（）、 arrayListof（）函数返回的 Lis 集合都是可变的 其中后面 个函数返回的集合类型都是明确的AmyList。创建可变的 List 集合之后，接下来就可以对该 List 的元素执行添加、插入、删除、替换 等操作了。原来在可变的 Set中介绍的方法，可变的 List 也完全支持，它还增加了 些根据索引执行插入、删除、替换的方法。
val colors = mutableListOf<String>("red", "black", "white", "green")
println(colors)
println("----------------------")
colors.add("yellow")
println(colors)
println("----------------------")
colors.remove("black")
println(colors)
println("----------------------")
colors[0] = "new red"
println(colors)
println("----------------------")
colors.clear()
println("colors.size = ${colors.size}")
运行结果：
[red, black, white, green]
----------------------
[red, black, white, green, yellow]
----------------------
[red, white, green, yellow]
----------------------
[new red, white, green, yellow]
----------------------
colors.size = 0三、Map集合
1. 声明和创建Map集合
Kotlin提供了如下函数来创建 Map 集合
（1）mapOf（）： 该函数返回不可变的 Map 集合。该函数可接受0个或多个 key-value对，这些key-value 对将作为 Map 的元素。
//不可变集合，按添加顺序排列
val map = mapOf<Int, String>(2 to "b", 1 to "a", 3 to "c")
println(map)
运行结果：
{2=b, 1=a, 3=c}（2）mutableMapOf（）： 该函数返回可变的mutableMap集合。该函数可接受0个或多个
key-value 对，这些 key-value 对将作为集合的元素。
//可变集合，按添加顺序排列
val mutableMap = mutableMapOf<Int, String>(2 to "b", 1 to "a", 3 to "c")
println(mutableMap)
运行结果：
{2=b, 1=a, 3=c}（3）hashMapOf（）： 该函数返回可变的 Has rfap 集合。该函数可接受0个或多个 key-value对，这些 key-value 将作为 Map 的元素。
//可变集合，不保证添加顺序排列
val hashMap = hashMapOf<Int, String>(2 to "b", 1 to "a", 3 to "c")
println(hashMap)
运行结果：
{1=a, 2=b, 3=c}（4）linkedMapOf（）：该函数返回可变的 LinkedHashMap 集合。该函数可接受0个或多个key-value 对，这些 key-value 对将作为 Map 的元素
//可变集合，按添加顺序排列
val linkedHashMap = linkedMapOf<Int, String>(2 to "b", 1 to "a", 3 to "c")
println(linkedHashMap)
运行结果：
{2=b, 1=a, 3=c}（5）sortedMapOf（）：该函数返回可变的 TreeMap 集合。该函数可接受0个或多个 key-value 对，这些 key-value 对将作 Map 的元素。
//可变集合，按KEY由小到大排列
val sortedMap = sortedMapOf(2 to "b", 1 to "a", 3 to "c")
println(sortedMap)
运行结果：
{1=a, 2=b, 3=c}2. 遍历Map
val colorMap = mapOf<String, String>("blue" to "蓝色", "balck" to "黑色", "white" to "白色")
for (color in colorMap) {
println("${color.key} -> ${color.value}")
}
println("-------------")
for ((k, v) in colorMap) {
println("$k -> $v")
}
println("-------------")
colorMap.forEach {
println("${it.key} -> ${it.value}")
}
运行结果：
blue -> 蓝色
balck -> 黑色
white -> 白色
-------------
blue -> 蓝色
balck -> 黑色
white -> 白色
-------------
blue -> 蓝色
balck -> 黑色
white -> 白色3. 可变的Map
除使用 mapOf（）函数返回的集合是不可变集合之外，使用 mutableMapOf（）、 hashMapOf（）、linkedMapOf（）、 sortedMapOf（）函数返回的集合都是可变的，其中后面三个函数返回的集合类型都是明确的，依次是 HashMap、LinkedHashMap、TreeMap。创建可变的 Map 集合之后，接下来就可以对该 Map 的元素执行添加、删除、替换操作了。
val fruitMap = mutableMapOf<String, String>("banana" to "黄色", "apple" to "红色")
println(fruitMap)
println("--------------------------")
fruitMap["banana"] = "黄色的😯"
println(fruitMap)
println("--------------------------")
fruitMap.remove("apple")
println(fruitMap)
println("--------------------------")
fruitMap.clear()
println("fruitMap.size = ${fruitMap.size}")
运行结果：
{banana=黄色, apple=红色}
--------------------------
{banana=黄色的😯, apple=红色}
--------------------------
{banana=黄色的😯}
--------------------------
fruitMap.size = 0
5200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
