编辑“︁Kotlin数组操作”︁（章节）

= Kotlin数组操作 =
'''数组(Array)'''是Kotlin中最基础的数据结构之一，用于存储固定大小的同类型元素集合。Kotlin提供了丰富的原生操作和扩展函数来处理数组。

== 数组基础 ==
Kotlin中的数组由`Array`类表示，与Java不同，Kotlin数组是'''类型安全'''的。创建数组的主要方式有：

=== 创建数组 ===
<syntaxhighlight lang="kotlin">
// 方式1：使用arrayOf函数
val numbers = arrayOf(1, 2, 3, 4, 5)

// 方式2：使用Array构造函数
val squares = Array(5) { i -> (i + 1) * (i + 1) }

// 方式3：原生类型数组（避免装箱开销）
val byteArray = byteArrayOf(1, 2, 3)
val intArray = intArrayOf(4, 5, 6)
</syntaxhighlight>

=== 数组类型体系 ===
<mermaid>
classDiagram
    Array <|-- ByteArray
    Array <|-- ShortArray
    Array <|-- IntArray
    Array <|-- LongArray
    Array <|-- FloatArray
    Array <|-- DoubleArray
    Array <|-- BooleanArray
    Array <|-- CharArray
    class Array {
        +size: Int
        +get(index: Int): T
        +set(index: Int, value: T)
    }
</mermaid>

== 核心操作 ==
=== 访问与修改 ===
<syntaxhighlight lang="kotlin">
val languages = arrayOf("Kotlin", "Java", "Python")

// 通过索引访问
println(languages[0])  // 输出: Kotlin

// 修改元素
languages[1] = "C++"
println(languages.joinToString())  // 输出: Kotlin, C++, Python

// 安全访问
val index = 5
println(languages.getOrNull(index) ?: "Index out of bounds")
</syntaxhighlight>

=== 遍历数组 ===
Kotlin提供多种遍历方式：
<syntaxhighlight lang="kotlin">
val colors = arrayOf("Red", "Green", "Blue")

// 方式1：for循环
for (color in colors) {
    println(color)
}

// 方式2：forEach高阶函数
colors.forEach { println(it.uppercase()) }

// 方式3：带索引遍历
colors.forEachIndexed { index, color ->
    println("$index: $color")
}
</syntaxhighlight>

== 常用操作函数 ==
Kotlin为数组提供了丰富的扩展函数：

=== 转换操作 ===
<syntaxhighlight lang="kotlin">
val nums = intArrayOf(1, 2, 3)

// map: 转换为新数组
val doubled = nums.map { it * 2 }  // 返回List<Int>
println(doubled)  // 输出: [2, 4, 6]

// filter: 过滤元素
val evens = nums.filter { it % 2 == 0 }
println(evens)  // 输出: [2]
</syntaxhighlight>

=== 聚合操作 ===
<syntaxhighlight lang="kotlin">
val prices = doubleArrayOf(12.5, 8.0, 9.99)

// 求和
val total = prices.sum()
println("Total: $total")  // 输出: Total: 30.49

// 最大值/最小值
println("Max: ${prices.max()}")  // 输出: Max: 12.5
println("Min: ${prices.min()}")  // 输出: Min: 8.0
</syntaxhighlight>

=== 排序操作 ===
<syntaxhighlight lang="kotlin">
val randomNumbers = intArrayOf(3, 1, 4, 1, 5, 9)

// 升序排序（不修改原数组）
val sortedAsc = randomNumbers.sorted()
println(sortedAsc)  // 输出: [1, 1, 3, 4, 5, 9]

// 降序排序（修改原数组）
randomNumbers.sortDescending()
println(randomNumbers.toList())  // 输出: [9, 5, 4, 3, 1, 1]
</syntaxhighlight>

== 多维数组 ==
Kotlin支持创建多维数组来处理矩阵等数据结构：
<syntaxhighlight lang="kotlin">
// 创建二维数组
val matrix = Array(3) { IntArray(3) { 0 } }

// 初始化矩阵
for (i in 0..2) {
    for (j in 0..2) {
        matrix[i][j] = i + j
    }
}

// 打印矩阵
matrix.forEach { row ->
    println(row.joinToString())
}
/* 输出:
0, 1, 2
1, 2, 3
2, 3, 4
*/
</syntaxhighlight>

== 性能考虑 ==
Kotlin数组操作的时间复杂度：
{| class="wikitable"
|+ 常见操作复杂度
! 操作 !! 时间复杂度
|-
| 随机访问 || O(1)
|-
| 线性搜索 || O(n)
|-
| 排序 || O(n log n)
|-
| 复制 || O(n)
|}

数学表示：对于长度为<math>n</math>的数组，搜索操作平均需要<math>\frac{n}{2}</math>次比较。

== 实际应用案例 ==
=== 案例1：成绩统计 ===
<syntaxhighlight lang="kotlin">
fun analyzeScores(scores: IntArray) {
    val average = scores.average()
    val passed = scores.count { it >= 60 }
    val distribution = scores.groupBy { it / 10 * 10 }
    
    println("平均分: $average")
    println("及格人数: $passed")
    distribution.forEach { (range, list) ->
        println("$range-${range+9}分: ${list.size}人")
    }
}

// 使用示例
val testScores = intArrayOf(85, 92, 78, 45, 67, 89, 53, 91)
analyzeScores(testScores)
</syntaxhighlight>

=== 案例2：图像处理 ===
处理图像的像素矩阵：
<syntaxhighlight lang="kotlin">
fun applyGrayscale(pixels: Array<IntArray>) {
    for (row in pixels.indices) {
        for (col in pixels[row].indices) {
            val color = pixels[row][col]
            val gray = (0.299 * (color shr 16 and 0xFF) + 
                       0.587 * (color shr 8 and 0xFF) + 
                       0.114 * (color and 0xFF)).toInt()
            pixels[row][col] = (gray shl 16) or (gray shl 8) or gray
        }
    }
}
</syntaxhighlight>

== 最佳实践 ==
* 优先使用原生类型数组（如`IntArray`）以减少内存开销
* 对大型数组使用`forEach`而非传统`for`循环，可获得更好的FP支持
* 需要频繁增删元素时考虑使用`List`而非数组
* 使用`contentEquals`比较数组内容而非`==`运算符

{{Warning|Kotlin数组大小固定，尝试访问越界索引会抛出`ArrayIndexOutOfBoundsException`}}

== 参见 ==
* [[Kotlin集合操作]]
* [[Kotlin性能优化技巧]]
* [[函数式编程与数组处理]]

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin数据结构]]