编辑“︁Kotlin嵌套循环”︁

{{Note|本文是Kotlin控制流系列的一部分，重点讲解嵌套循环的概念及其应用。}}

= Kotlin嵌套循环 =

'''嵌套循环'''是指在一个循环体内包含另一个循环的结构。这种结构在需要处理多维数据（如二维数组、矩阵）或执行重复性分层操作时非常有用。Kotlin支持所有主流循环类型（`for`、`while`、`do-while`）的嵌套。

== 基本概念 ==
嵌套循环的工作原理是：
* 外层循环每执行一次，内层循环会完整执行所有迭代
* 循环层次可以无限嵌套（但通常建议不超过3层以提高可读性）
* 可以使用`break`和`continue`控制特定层级的循环

数学上，若外层循环执行''n''次，内层循环执行''m''次，则总迭代次数为：
<math>Total = n \times m</math>

== 语法示例 ==
=== 基础嵌套for循环 ===
最常见的嵌套形式是`for`循环的嵌套：

<syntaxhighlight lang="kotlin">
fun main() {
    // 外层循环控制行
    for (i in 1..3) {
        // 内层循环控制列
        for (j in 1..5) {
            print("($i,$j) ")
        }
        println() // 换行
    }
}
</syntaxhighlight>

'''输出：'''
<pre>
(1,1) (1,2) (1,3) (1,4) (1,5) 
(2,1) (2,2) (2,3) (2,4) (2,5) 
(3,1) (3,2) (3,3) (3,4) (3,5)
</pre>

=== while循环嵌套 ===
<syntaxhighlight lang="kotlin">
fun main() {
    var i = 1
    while (i <= 2) {
        var j = 1
        while (j <= 3) {
            println("i=$i, j=$j")
            j++
        }
        i++
    }
}
</syntaxhighlight>

'''输出：'''
<pre>
i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
i=2, j=3
</pre>

== 流程控制 ==
使用标签(label)可以精确控制嵌套循环的流程：

<syntaxhighlight lang="kotlin">
fun main() {
    outer@ for (i in 1..3) {
        inner@ for (j in 1..3) {
            if (i == 2 && j == 2) break@outer
            println("$i-$j")
        }
    }
}
</syntaxhighlight>

'''输出：'''
<pre>
1-1
1-2
1-3
2-1
</pre>

== 实际应用案例 ==
=== 案例1：乘法表 ===
<syntaxhighlight lang="kotlin">
fun printMultiplicationTable(size: Int) {
    for (i in 1..size) {
        for (j in 1..size) {
            print("${i * j}\t")
        }
        println()
    }
}

fun main() {
    printMultiplicationTable(5)
}
</syntaxhighlight>

'''输出：'''
<pre>
1   2   3   4   5   
2   4   6   8   10  
3   6   9   12  15  
4   8   12  16  20  
5   10  15  20  25  
</pre>

=== 案例2：二维数组处理 ===
<syntaxhighlight lang="kotlin">
fun findInMatrix(matrix: Array<Array<Int>>, target: Int): Pair<Int, Int>? {
    matrix.forEachIndexed { i, row ->
        row.forEachIndexed { j, value ->
            if (value == target) return i to j
        }
    }
    return null
}

fun main() {
    val matrix = arrayOf(
        arrayOf(1, 2, 3),
        arrayOf(4, 5, 6),
        arrayOf(7, 8, 9)
    )
    println(findInMatrix(matrix, 5)) // 输出: (1, 1)
}
</syntaxhighlight>

== 性能注意事项 ==
* 嵌套层级越深，时间复杂度增长越快（O(n^k)）
* 避免在深层嵌套中使用复杂计算
* 当可能时，考虑使用扁平化处理或内置函数（如`flatMap`）

== 可视化流程 ==
<mermaid>
graph TD
    A[外层循环开始] --> B{外层条件}
    B -- 真 --> C[内层循环开始]
    C --> D{内层条件}
    D -- 真 --> E[执行循环体]
    E --> D
    D -- 假 --> F[外层循环迭代]
    F --> B
    B -- 假 --> G[结束]
</mermaid>

== 进阶技巧 ==
=== 使用return从多层循环退出 ===
<syntaxhighlight lang="kotlin">
fun findFirstNegative(matrix: Array<Array<Int>>): Int? {
    matrix.forEach { row ->
        row.forEach { num ->
            if (num < 0) return num
        }
    }
    return null
}
</syntaxhighlight>

=== 条件嵌套 ===
可以在循环条件中加入嵌套判断：
<syntaxhighlight lang="kotlin">
fun main() {
    for (i in 1..10) {
        for (j in 1..10) {
            if (i % 2 == 0 && j % 2 != 0) {
                println("Even row $i, odd column $j")
            }
        }
    }
}
</syntaxhighlight>

== 常见错误与调试 ==
{| class="wikitable"
|-
! 错误类型 !! 示例 !! 解决方法
|-
| 无限循环 || 忘记更新内层循环变量 || 确保所有循环变量都有正确的迭代
|-
| 标签错误 || 使用未定义的标签 || 确保标签名一致且带@符号
|-
| 性能问题 || 深层嵌套处理大数据 || 考虑算法优化或使用函数式操作
|}

{{Tip|使用Kotlin的`forEach`系列函数可以减少嵌套循环的样板代码，同时提高可读性。}}

== 总结 ==
* 嵌套循环是处理多维数据的有效工具
* Kotlin支持所有循环类型的任意嵌套组合
* 使用标签可以精确控制流程
* 注意嵌套深度对性能的影响
* 结合Kotlin特性可以写出更简洁的嵌套逻辑

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin控制流]]