kotlin数组与集合

数组

数组在 Kotlin 中由 Array 类表示，有 get 和 set 方法(通过运算符重载可以由[]调用)，以及 size 方法，以及一些常用的函数：

class Array<T> private constructor() {
	val size: Int
	operator fun get(index: Int): T
	operator fun set(index: Int, value: T): Unit
	operator fun iterator(): Iterator<T>
	// ...
}

我们可以给库函数 arrayOf() 传递每一项的值来创建Array， arrayOf(1, 2,3) 创建了一个[1, 2, 3] 这样的数组。也可以使用库函数 arrayOfNulls() 创建一个指定大小的空Array。

泛型创建数组

//因为初始值给了类型所以这里我们就不用arrayOf<Int>()
val arr:Array<Int> = arrayOf(1,3,4,5)
println(arr.size)
println(arr[2])

指定类型创建数组

val arr:IntArray = intArrayOf(1,3,4,5)
println(arr.size)
println(arr[2])

这里注意intArrayOf返回的是IntArray，所以不能使用Array的方式声明变量的类型，除了intArrayOf还有其他基本数据类型

多种创建方式

在 Kotlin 中，有多种方式可以创建数组。以下是其中的几种：

1. 使用 arrayOf() 函数创建数组
   使用 arrayOf() 函数可以创建一个包含指定元素的数组。例如：

val arr = arrayOf(1, 2, 3, 4, 5)

这将创建一个包含整数 1 到 5 的数组。
2. 使用 Array 构造函数创建数组
使用 Array() 构造函数也可以创建数组。例如：

val arr = Array(5) { i -> i * 2 }

这将创建一个包含 5 个元素的数组，其中每个元素的值为其下标的两倍。
3. 使用 Array(size) 函数创建空数组
可以使用 Array(size) 函数创建一个指定大小的空数组。例如：

val arr = Array(5) { 0 }

这将创建一个包含 5 个元素的数组，所有元素的值都为 0。
4. 使用 arrayOfNulls() 函数创建空数组
可以使用 arrayOfNulls() 函数创建一个指定大小的空数组，并将每个元素初始化为 null。例如：

val arr = arrayOfNulls<Int>(5)

这将创建一个包含 5 个元素的数组，所有元素的值都为 null。
无论使用哪种方法创建数组，都可以使用下标访问数组中的元素，并可以使用 size 属性获取数组的大小。例如：

val arr = arrayOf(1, 2, 3, 4, 5)
println(arr[0])   // 输出：1
println(arr.size) // 输出：5

集合

List与Set

首先创建了一个不可变列表和一个可变列表，然后使用 for 循环遍历它们并打印每个元素。接下来，我们创建了一个不可变集合和一个可变集合，添加了一个新元素，并使用 for 循环遍历它们并打印每个元素。

需要注意的是 mutable，对于不可变集合和列表，我们不能添加、删除或修改其中的元素，因为它们是不可变的。而对于可变集合和列表，我们可以添加、删除或修改其中的元素。

// 创建不可变列表
val list = listOf("apple", "banana", "orange")
// 循环遍历列表并打印元素
for (item in list) {
    println(item)
}
// 创建可变列表
val mutableList = mutableListOf("apple", "banana", "orange")
// 添加一个新元素
mutableList.add("grape")
// 循环遍历可变列表并打印元素
for (item in mutableList) {
    println(item)
}
// 创建不可变集合
val set = setOf("apple", "banana", "orange")
// 循环遍历集合并打印元素
for (item in set) {
    println(item)
}
// 创建可变集合
val mutableSet = mutableSetOf("apple", "banana", "orange")
// 添加一个新元素
mutableSet.add("grape")
// 循环遍历可变集合并打印元素
for (item in mutableSet) {
    println(item)
}

forEach

创建了一个不可变列表和一个可变列表，然后使用 forEach 循环遍历它们并打印每个元素。forEach 函数接受一个 lambda 表达式作为参数，该 lambda 表达式将在每个元素上被调用。在 lambda 表达式中，我们使用 item 变量来引用当前元素。

接下来，我们创建了一个不可变集合和一个可变集合，添加了一个新元素，并使用 forEach 循环遍历它们并打印每个元素。

需要注意的是，forEach 函数是一种更简洁的方式来遍历集合，而不需要使用显式的循环语句。另外，forEach 函数是在 Kotlin 标准库中定义的，可用于所有类型的集合。

// 创建不可变列表
val list = listOf("apple", "banana", "orange")
// 使用 forEach 循环遍历列表并打印元素
list.forEach { item ->
    println(item)
}
// 创建可变列表
val mutableList = mutableListOf("apple", "banana", "orange")

// 添加一个新元素
mutableList.add("grape")

// 使用 forEach 循环遍历可变列表并打印元素
mutableList.forEach { item ->
    println(item)
}
// 创建不可变集合
val set = setOf("apple", "banana", "orange")
// 使用 forEach 循环遍历集合并打印元素
set.forEach { item ->
    println(item)
}
// 创建可变集合
val mutableSet = mutableSetOf("apple", "banana", "orange")

// 添加一个新元素
mutableSet.add("grape")
// 使用 forEach 循环遍历可变集合并打印元素
mutableSet.forEach { item ->
    println(item)
}

Map

// 创建不可变 Map
val map = mapOf(
    "apple" to 1,
    "banana" to 2,
    "orange" to 3
)
// 循环遍历 Map 并打印键值对
for ((key, value) in map) {
    println("key: $key, value: $value")
}
// 创建可变 Map
val mutableMap = mutableMapOf(
    "apple" to 1,
    "banana" to 2,
    "orange" to 3
)
// 添加一个新键值对
mutableMap["grape"] = 4
// 循环遍历可变 Map 并打印键值对
for ((key, value) in mutableMap) {
    println("key: $key, value: $value")
}

需要注意的是，对于不可变 Map，我们不能添加、删除或修改其中的键值对，因为它们是不可变的。而对于可变 Map，我们可以添加、删除或修改其中的键值对

forEach

forEach 函数是一种更简洁的方式来遍历 Map，而不需要使用显式的循环语句。另外，forEach 函数是在 Kotlin 标准库中定义的，可用于所有类型的 Map。

// 创建不可变 Map
val map = mapOf(
    "apple" to 1,
    "banana" to 2,
    "orange" to 3
)
// 使用 forEach 循环遍历 Map 并打印键值对
map.forEach { (key, value) ->
    println("key: $key, value: $value")
}
// 创建可变 Map
val mutableMap = mutableMapOf(
    "apple" to 1,
    "banana" to 2,
    "orange" to 3
)
// 添加一个新键值对
mutableMap["grape"] = 4
// 使用 forEach 循环遍历可变 Map 并打印键值对
mutableMap.forEach { (key, value) ->
    println("key: $key, value: $value")
}

元组

首先使用 Pair 和 Triple 类分别创建具有两个元素和三个元素的元组。然后，我们使用解构来访问元组元素并打印
使用数据类 Fruit 创建一个具有三个元素的元组。我们可以使用数据类的组件来访问元组元素，并使用字符串插值来打印

// 使用 Pair 类创建元组
val pair = Pair("apple", 1)
// 使用解构来访问元组元素
val (fruit, quantity) = pair
println("fruit: $fruit, quantity: $quantity")
// 使用 Triple 类创建元组
val triple = Triple("apple", 1, 2.99)
// 使用解构来访问元组元素
val (fruit2, quantity2, price) = triple
println("fruit2: $fruit2, quantity2: $quantity2, price: $price")
// 使用数据类创建元组
data class Fruit(val name: String, val quantity: Int, val price: Double)
val fruitTuple = Fruit("apple", 1, 2.99)
// 使用数据类的组件来访问元组元素
println("fruitTuple: ${fruitTuple.name}, ${fruitTuple.quantity}, ${fruitTuple.price}")