【文字内容源于《疯狂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