Kotlin嵌套循环

Kotlin嵌套循环

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

基本概念

嵌套循环的工作原理是：

• 外层循环每执行一次，内层循环会完整执行所有迭代
• 循环层次可以无限嵌套（但通常建议不超过3层以提高可读性）
• 可以使用`break`和`continue`控制特定层级的循环

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

语法示例

基础嵌套for循环

最常见的嵌套形式是`for`循环的嵌套：

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

输出：

(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)

while循环嵌套

fun main() {
    var i = 1
    while (i <= 2) {
        var j = 1
        while (j <= 3) {
            println("i=$i, j=$j")
            j++
        }
        i++
    }
}

输出：

i=1, j=1
i=1, j=2
i=1, j=3
i=2, j=1
i=2, j=2
i=2, j=3

流程控制

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

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

输出：

1-1
1-2
1-3
2-1

实际应用案例

案例1：乘法表

fun printMultiplicationTable(size: Int) {
    for (i in 1..size) {
        for (j in 1..size) {
            print("${i * j}\t")
        }
        println()
    }
}

fun main() {
    printMultiplicationTable(5)
}

输出：

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  

案例2：二维数组处理

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)
}

性能注意事项

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

可视化流程

graph TD A[外层循环开始] --> B{外层条件} B -- 真 --> C[内层循环开始] C --> D{内层条件} D -- 真 --> E[执行循环体] E --> D D -- 假 --> F[外层循环迭代] F --> B B -- 假 --> G[结束]

进阶技巧

使用return从多层循环退出

fun findFirstNegative(matrix: Array<Array<Int>>): Int? {
    matrix.forEach { row ->
        row.forEach { num ->
            if (num < 0) return num
        }
    }
    return null
}

条件嵌套

可以在循环条件中加入嵌套判断：

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")
            }
        }
    }
}

常见错误与调试

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

总结

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