Kotlin 笔记 数据容器（九）
Kotlin笔记数据类型（一）
Kotlin笔记字符串（二）
Kotlin笔记运算符（三）
Kotlin笔记函数（四）
Kotlin笔记面向对象（五）
Kotlin笔记继承、抽象类、接口（六）
Kotlin笔记高阶函数（七）
Kotlin笔记泛型（八）
文章目录
一、数组
1、对象数组使用
fun main(args: Array<String>) {
// 静态初始化
val intArray1 = arrayOf(21, 32, 43, 45) ①
val strArray1 = arrayOf("张三", "李四", "王五", "董六") ②
// 动态初始化
val strArray2 = arrayOfNulls<String>(4) ③
// 初始化数组中元素
strArray2[0] = "张三"
strArray2[1] = "李四"
strArray2[2] = "王五"
strArray2[3] = "董六"
val intArray2 = Array<Int>(10) {
i -> i * i }//可以使用{ it * it }替代 ④
val intArray3 = Array<Int?>(10) {
it * it * it } //可以使用{ i -> i * i * i }替代 ⑤
//遍历集合
for (item in intArray2) {
⑥
println(item)
}
for (idx in strArray1.indices) {
⑦
println(strArray1[idx])
}
}
2、基本数据类型数组
fun main(args: Array<String>) {
// 静态初始化
val array1 = shortArrayOf(20, 10, 50, 40, 30) ①
// 动态初始化
val array2 = CharArray(3) ②
array2[0] = 'C'
array2[1] = 'B'
array2[2] = 'D'
// 动态初始化
val array3 = IntArray(10) {
it * it } ③
299
//遍历集合
for (item in array3) {
④
println(item)
}
println()
for (idx in array2.indices) {
⑤
println(array2[idx])
}
}
二、集合
1.set集合
Set集合是由一串无序的，不能重复的相同类型元素构成的集合
2、不可变Set集合
fun main(args: Array<String>) {
val set1 = setOf("ABC") //[ABC]
val set2 = setOf<Long?>() //[]
val set3 = setOf(1, 3, 34, 54, 75)//[1, 3, 34, 54, 75]
println(set1.size) //1
println(set2.isEmpty()) //true
println(set3.contains(75)) //true
// 1.使用for循环遍历
println("--1.使用for循环遍历--")
for (item in set3) {
⑦
println("读取集合元素: $item")
}
// 2.使用迭代器遍历
println("--2.使用迭代器遍历--")
val it = set3.iterator()
while (it.hasNext()) {
val item = it.next()
println("读取集合元素: $item")
}
}
3、可变Set集合
fun main(args: Array<String>) {
val set1 = mutableSetOf(1, 3, 34, 54, 75) ①
val set2 = mutableSetOf<String>() ②
val set3 = hashSetOf<Long?>() ③
val set4 = hashSetOf("B", "D", "F") ④
val b = "B"
// 向set2集合中添加元素
set2.add("A")
set2.add(b) ⑤
set2.add("C")
set2.add(b) ⑥
set2.add("D")
set2.add("E")
// 打印集合元素个数
println("集合size = ${set2.size}") //5 ⑦
// 打印集合
println(set2)
// 删除集合中第一个"B"元素
set2.remove(b)
// 判断集合中是否包含"B"元素
println("""是否包含"B"：${set2.contains(b)}""") //false
// 判断集合是否为空
println("set集合是空的：${set2.isEmpty()}") //false
// 清空集合
set2.clear()
println(set2.isEmpty()) //true
// 向set3集合中添加元素
set3.add(3)
set3.add(4)
set3.add(6)
// 1.使用for循环遍历
println("--1.使用for循环遍历--")
for (item in set2) {
println("读取集合元素: $item")
}
// 2.使用迭代器遍历
println("--2.使用迭代器遍历--")
val it = set3.iterator()
while (it.hasNext()) {
val item = it.next()
println("读取集合元素: $item")
}
}
2、list集合
List集合中的元素是有序的，可以重复出现
1、不可变的list
fun main(args: Array<String>) {
val list1 = listOf("ABC") //[ABC] ①
val list2 = listOf<Long?>() //[] ②
val list3 = listOf(3, 34, 54, 75)//[3, 75, 54, 75] ③
val list4 = list3.subList(1, 3)//[75, 54] ④
println(list1.size) //1
println(list2.isEmpty()) //true
println(list3.contains(54)) //true
println(list3.indexOf(75)) //1 ⑤
println(list3.lastIndexOf(75)) //3 ⑥
//通过下标访问
println(list3[1]) //75 ⑦
// 1.使用for循环遍历
println("--1.使用for循环遍历--")
for (item in list3) {
println("读取集合元素: $item")
}
// 2.使用迭代器遍历
println("--2.使用迭代器遍历--")
val it = list3.iterator()
while (it.hasNext()) {
val item = it.next()
println("读取集合元素: $item")
}
}
2、可变的list
fun main(args: Array<String>) {
val list1 = mutableListOf(1, 3, 34, 54, 75) ①
val list2 = mutableListOf<String>() ②
val list3 = arrayListOf<Long?>() ③
val list4 = arrayListOf("B", "D", "F") ④
val b = "B"
// 向list2集合中添加元素
list2.add("A")
list2.add(b) ⑤
list2.add("C")
list2.add(b) ⑥
list2.add("D")
list2.add("E")
// 打印集合元素个数
println("集合size = ${list2.size}")//6 ⑦
// 打印集合
println(list2)
// 删除集合中第一个"B"元素
list2.remove(b)
// 判断集合中是否包含"B"元素
println("""是否包含"B"：${list2.contains(b)}""")//true
// 判断集合是否为空
println("集合是空的：${list2.isEmpty()}")//false
// 清空集合
list2.clear()
println(list2.isEmpty())//true
// 向list3集合中添加元素
list3.add(3)
list3.add(4)
308
list3.add(6)
// 1.使用for循环遍历
println("--1.使用for循环遍历--")
for (item in list2) {
println("读取集合元素: $item")
}
// 2.使用迭代器遍历
println("--2.使用迭代器遍历--")
val it = list3.iterator()
while (it.hasNext()) {
val item = it.next()
println("读取集合元素: $item")
}
}
3、Map集合
Map（映射）集合表示一种非常复杂的集合，允许按照某个键来访问元素。Map集合是由两
个集合构成的，一个是键（key）集合，一个是值（value）集合。键集合是Set类型，因
此不能有重复的元素
1、不可变Map集合
fun main(args: Array<String>) {
val map1 = mapOf(102 to "张三", 105 to "李四", 109 to "王五") ①
val map2 = mapOf<Int, String>() ②
val map3 = mapOf(1 to 200) ③
// 打印集合元素个数
println("集合size = " + map1.size) //3 ④
// 打印集合
println(map1)//{102=张三, 105=李四, 109=王五}
// 通过键取值
println("102 - ${map1[102]}")//102 - 张三 ⑤
println("105 - ${map1[105]}")//105 - 李四
// 判断键集合中是否包含109
println("键集合中是否包含109：${map1.containsKey(109)}")//true
// 判断值集合中是否包含 "李四"
println("值集合中是否包含\"李四\"：${map1.containsValue("李四")}")//true
// 判断集合是否为空
println("集合是空的：" + map2.isEmpty())//true
// 1.使用for循环遍历
println("--1.使用for循环遍历--")
// 获得键集合
val keys = map1.keys ⑥
for (key in keys) {
println("key=${key} - value=${map1[key]}")
}
// 2.使用迭代器遍历
println("--2.使用迭代器遍历--")
// 获得值集合
val values = map1.values ⑦
// 遍历值集合
val it = values.iterator()
while (it.hasNext()) {
val item = it.next()
println("值集合元素: $item")
}
}
2、可变Map集合
fun main(args: Array<String>) {
val map1 = mutableMapOf<Int, String>() ①
val map2 = mutableMapOf(1 to 102, 2 to 360) ②
val map3 = hashMapOf<Long, String>() ③
val map4 = hashMapOf("R" to "Read", "C" to "Create") ④
map1.put(102, "张三") ⑤
map1[105] = "李四" ⑥
map1[109] = "王五"
map1[110] = "董六"
//"李四"值重复
map1[111] = "李四" ⑦
//109键已经存在，替换原来值"王五"
map1[109] = "刘备" ⑧
// 打印集合元素个数
println("集合size = " + map1.size)//5
// 打印集合
println(map1)//{102=张三, 105=李四, 109=刘备, 110=董六, 111=李四}
// 删除键值对
map1.remove(109) ⑨
// 判断键集合中是否包含109
println("键集合中是否包含109：${map1.containsKey(109)}")//false
// 判断值集合中是否包含 "李四"
println("值集合中是否包含\"李四\"：${map1.containsValue("李四")}")//true
// 判断集合是否为空
println("集合是空的：" + map2.isEmpty())//false
// 清空集合
map1.clear() ⑩
// 打印集合
println(map1)//{}
参 考：Kotlin从小白到大牛