数组
数组在 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 中,有多种方式可以创建数组。以下是其中的几种:
- 使用 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}")