Kotlin 数组详解：定义、操作与应用 – wiki基地

作者： /

Here’s my plan:
1. Outline the article structure: I’ll define the main sections and subsections for clarity.
2. Generate content for each section: I will write detailed explanations, code examples, and use cases.
3. Create a markdown file: I will save the generated content into a markdown file named kotlin_arrays_guide.md.

Here’s the detailed plan for the article’s content:

  • Title: Kotlin 数组详解：定义、操作与应用
  • Introduction: Briefly introduce what arrays are and their importance in programming.
  • 1. 数组的定义 (Array Definition)
    • 1.1. Array<T> 类
    • 1.2. 基本数据类型数组 (Primitive Type Arrays) – IntArray, CharArray, etc.
    • 1.3. 数组的创建 (Array Creation)
      • 使用 arrayOf()
      • 使用 arrayOfNulls()
      • 使用 Array 构造函数 (Lambda 初始化)
      • 使用基本类型数组的构造函数 (intArrayOf(), BooleanArray(), etc.)
  • 2. 数组的访问与操作 (Array Access and Operations)
    • 2.1. 获取数组长度 (size)
    • 2.2. 元素访问 (使用 [] 运算符, get(), set())
    • 2.3. 遍历数组
      • 使用 for 循环
      • 使用 forEach
      • 使用 indices 或 withIndex
    • 2.4. 常用操作函数
      • first(), last()
      • indexOf(), lastIndexOf()
      • contains(), isEmpty(), isNotEmpty()
      • plus() (连接数组)
      • slice(), sliceArray()
      • sort(), sortedArray(), reverse(), reversedArray()
      • map(), filter(), reduce(), fold()
  • 3. 多维数组 (Multidimensional Arrays)
    • 概念介绍与定义
    • 访问与遍历
  • 4. 数组与列表/集合的转换 (Array and List/Collection Conversion)
    • 数组转列表 (toList(), toMutableList())
    • 列表转数组 (toTypedArray(), toIntArray(), etc.)
  • 5. 数组的应用场景 (Application Scenarios of Arrays)
    • 数据存储
    • 算法实现 (排序, 搜索)
    • 函数参数传递
  • Conclusion: Summarize key takeaways.

I will now proceed to generate the content and create the file.I will now write the content for the article “Kotlin 数组详解：定义、操作与应用” and save it to kotlin_arrays_guide.md.好的，这是一篇关于“Kotlin 数组详解：定义、操作与应用”的文章。

Kotlin 数组详解：定义、操作与应用

在编程中，数组是一种最基本的数据结构，用于存储固定大小的同类型元素序列。Kotlin 提供了强大且灵活的数组机制，既有传统数组的性能优势，又融入了 Kotlin 语言的现代特性。本文将深入探讨 Kotlin 数组的定义、常见操作以及实际应用场景。

一、Kotlin 数组的定义与初始化

Kotlin 中的数组是一个包含固定数量元素的容器，这些元素类型相同。与 Java 不同，Kotlin 不直接使用 Java 的原生数组语法 int[]，而是通过类来表示数组。

1. Array<T> 类型

Array<T> 是 Kotlin 中表示数组的通用类型，其中 T 是数组元素的类型。

a. 使用 arrayOf() 函数
这是最常见、最简洁的数组初始化方式，直接传入元素即可。
“`kotlin
// 存储整数的数组
val intArray = arrayOf(1, 2, 3, 4, 5) // 类型推断为 Array

// 存储字符串的数组
val stringArray = arrayOf(“Apple”, “Banana”, “Cherry”) // 类型推断为 Array

// 存储混合类型（自动推断为 Any）
val mixedArray = arrayOf(1, “Hello”, true) // 类型推断为 Array
“`

b. 使用 arrayOfNulls() 函数
如果你只需要一个指定大小的数组，并且希望所有元素都初始化为 null，可以使用 arrayOfNulls()。需要注意的是，由于元素是 null，数组类型必须是可空的 (T?)。
kotlin
val nullableIntArray: Array<Int?> = arrayOfNulls(5) // 包含 5 个 null 元素的 Array<Int?>
println(nullableIntArray.contentToString()) // 输出: [null, null, null, null, null]

c. 使用构造函数 Array(size) { init }
这种方式允许你定义数组的大小，并通过一个 lambda 表达式来为每个元素提供初始值。lambda 表达式的参数是元素的索引。
“`kotlin
// 创建一个包含 5 个元素的数组，每个元素是其索引的平方
val squareArray = Array(5) { i -> i * i }
println(squareArray.contentToString()) // 输出: [0, 1, 4, 9, 16]

// 创建一个包含 3 个字符串的数组
val greetingArray = Array(3) { i -> “Hello ${i + 1}” }
println(greetingArray.contentToString()) // 输出: [Hello 1, Hello 2, Hello 3]
“`

2. 原始类型数组

为了避免装箱/拆箱带来的性能开销，Kotlin 提供了专门的原始类型数组，它们对应于 Java 的原始类型数组（如 int[], char[]）。
* ByteArray (byte)
* ShortArray (short)
* IntArray (int)
* LongArray (long)
* FloatArray (float)
* DoubleArray (double)
* CharArray (char)
* BooleanArray (boolean)

这些数组的用法与 Array<T> 类似，但只能存储对应的原始类型。

a. 使用 *ArrayOf() 函数
kotlin
val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
val flags: BooleanArray = booleanArrayOf(true, false, true)
val chars: CharArray = charArrayOf('K', 'o', 't', 'l', 'i', 'n')

b. 使用构造函数 *Array(size) { init }
kotlin
val zeroInts = IntArray(5) // 包含 5 个 0 的 IntArray
val alphabet = CharArray(26) { i -> 'a' + i } // 包含 'a' 到 'z' 的 CharArray
println(alphabet.contentToString()) // 输出: [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]

二、数组的基本操作

1. 访问元素

数组元素可以通过索引访问，索引从 0 开始。
“`kotlin
val array = arrayOf(“A”, “B”, “C”)

// 读取元素
val firstElement = array[0] // “A”
val secondElement = array.get(1) // “B” (等同于 array[1])

// 修改元素
array[2] = “D”
array.set(0, “Z”) // (等同于 array[0] = “Z”)
println(array.contentToString()) // 输出: [Z, B, D]
“`

2. 获取数组大小

使用 size 属性可以获取数组的元素数量。
kotlin
val numbers = intArrayOf(10, 20, 30)
println("数组大小: ${numbers.size}") // 输出: 数组大小: 3

3. 遍历数组

有多种方式可以遍历数组中的元素。

a. 使用 for 循环
“`kotlin
val fruits = arrayOf(“Apple”, “Banana”, “Cherry”)
for (fruit in fruits) {
println(fruit)
}

// 遍历带索引
for (i in fruits.indices) { // indices 属性返回索引范围 0..size-1
println(“Element at index $i: ${fruits[i]}”)
}

// 遍历带索引和值
for ((index, value) in fruits.withIndex()) {
println(“Index $index, Value $value”)
}
“`

b. 使用 forEach 函数
“`kotlin
fruits.forEach { fruit ->
println(fruit)
}

// 带索引的 forEach
fruits.forEachIndexed { index, fruit ->
println(“Element at index $index: $fruit”)
}
“`

三、数组的常用函数与扩展方法

Kotlin 为数组类型提供了丰富的扩展函数，使其操作更加便捷。

1. 检查与判断

  • isEmpty(): 检查数组是否为空。
  • isNotEmpty(): 检查数组是否不为空。
  • contains(element): 检查数组是否包含指定元素。
  • indexOf(element): 返回指定元素的第一个匹配索引，未找到则返回 -1。
  • lastIndexOf(element): 返回指定元素的最后一个匹配索引，未找到则返回 -1。

kotlin
val data = intArrayOf(1, 2, 3, 2, 5)
println(data.isEmpty()) // false
println(data.contains(3)) // true
println(data.indexOf(2)) // 1
println(data.lastIndexOf(2)) // 3

2. 排序与反转

  • sort(): 对数组进行原地升序排序 (对原始数组进行修改)。
  • sortedArray(): 返回一个新数组，包含原始数组的升序排序副本。
  • reverse(): 对数组进行原地反转 (对原始数组进行修改)。
  • reversedArray(): 返回一个新数组，包含原始数组的反转副本。

“`kotlin
val numbers = intArrayOf(5, 2, 8, 1, 9)
numbers.sort()
println(numbers.contentToString()) // 输出: [1, 2, 5, 8, 9]

val unsorted = intArrayOf(5, 2, 8)
val sorted = unsorted.sortedArray()
println(sorted.contentToString()) // 输出: [2, 5, 8]

unsorted.reverse()
println(unsorted.contentToString()) // 输出: [8, 2, 5]

val reversed = sorted.reversedArray()
println(reversed.contentToString()) // 输出: [8, 5, 2]
“`

3. 数学运算

  • sum(): 计算所有元素的总和。
  • average(): 计算所有元素的平均值。
  • minOrNull(): 返回最小值，如果数组为空则返回 null。
  • maxOrNull(): 返回最大值，如果数组为空则返回 null。

kotlin
val values = doubleArrayOf(10.0, 20.5, 30.0)
println(values.sum()) // 60.5
println(values.average()) // 20.1666...
println(values.minOrNull()) // 10.0
println(values.maxOrNull()) // 30.0

4. 转换与操作

  • plus(element) / plus(array): 返回一个新数组，包含原始数组的元素以及新添加的元素或另一个数组的元素。
  • slice(indices: IntRange) / slice(indices: Iterable<Int>): 截取数组的一部分，返回一个新的 List。
  • joinToString(separator: String = ", ", prefix: String = "", postfix: String = ""): 将数组元素拼接成一个字符串。
  • map { it * 2 }: 对数组中的每个元素应用一个转换函数，返回一个新的 List。
  • filter { it % 2 == 0 }: 过滤数组中的元素，返回一个新的 List。

“`kotlin
val original = intArrayOf(1, 2, 3)
val combined = original.plus(4)
println(combined.contentToString()) // 输出: [1, 2, 3, 4]

val sliceList = original.slice(0..1)
println(sliceList) // 输出: [1, 2]

val str = original.joinToString(separator = “-“, prefix = “[“, postfix = “]”)
println(str) // 输出: [1-2-3]

val doubled = original.map { it * 2 }
println(doubled) // 输出: [2, 4, 6]

val evens = original.filter { it % 2 == 0 }
println(evens) // 输出: [2]
“`

5. 多维数组

Kotlin 不直接支持像 int[][] 这样的多维数组语法，而是通过“数组的数组”来实现。

“`kotlin
// 创建一个 3×3 的二维整数数组
val multiArray = Array(3) { IntArray(3) }

// 初始化元素
multiArray[0][0] = 1
multiArray[1][1] = 5
multiArray[2][2] = 9

// 使用嵌套循环打印
for (row in multiArray) {
for (element in row) {
print(“$element “)
}
println()
}
/
输出:
1 0 0
0 5 0
0 0 9
/
“`

四、数组的应用场景

数组在各种编程任务中都有广泛应用：

  1. 数据存储: 存储固定数量的同类型数据，如传感器读数、像素数据、学生成绩等。
  2. 算法实现: 许多经典算法（如排序算法、搜索算法、动态规划）都以数组作为核心数据结构。
  3. 矩阵运算: 多维数组是表示和处理矩阵、图像等数据的理想选择。
  4. 缓冲区: 作为数据输入/输出的缓冲区，例如文件读写操作。
  5. 枚举值映射: 当需要将整数索引映射到特定值时，数组非常高效。
  6. 性能敏感场景: 对于需要高性能、避免频繁内存分配的场景，原始类型数组 (IntArray 等) 优于 List。

五、数组与列表 (List) 的选择

Kotlin 同时提供了数组和列表 (List/MutableList)。理解它们之间的区别对于做出正确的选择至关重要：

特性 数组 (Array<T>, IntArray 等) 列表 (List<T>, MutableList<T>)
大小 固定大小，一旦创建，大小不可变。 动态大小，可以添加或删除元素 (对于 MutableList)。
性能 通常性能更高，尤其是原始类型数组，避免装箱/拆箱。 封装了底层数组，可能存在一些额外开销。
可变性 元素可变 (除非使用 val 和不可变元素)。数组本身不可调整大小。 List 是不可变的；MutableList 是可变的。
类型 具体类型 (Array<Int>, IntArray) 接口 (List, MutableList)
用途 固定大小数据，性能敏感场景，底层实现。 灵活大小数据，集合操作，函数式编程。

何时使用数组：
* 当你明确知道数据量且不需要改变其大小时。
* 当你处理原始类型数据并关注性能时 (使用 IntArray 等)。
* 当你需要与 Java 互操作，特别是调用接受或返回 Java 原生数组的方法时。

何时使用列表：
* 当你需要一个可变大小的集合时。
* 当你需要丰富的集合操作函数 (如 add, remove, groupBy 等)。
* 当你更关注代码的灵活性和可读性，而不是极致的性能时。

总结

Kotlin 数组是处理固定序列数据的强大工具。通过 arrayOf()、arrayOfNulls() 和构造函数等多种初始化方式，以及丰富的扩展函数，开发者可以高效地定义、操作和管理数组。理解 Array<T> 与原始类型数组的区别，并根据具体需求在数组和列表之间做出明智的选择，将有助于编写出更高效、更健壮的 Kotlin 代码。

滚动至顶部