企业官网建设流程全解析

1. 引言

循环是编程语言中最基础也最常用的控制结构之一。Kotlin 作为一门现代 JVM 语言，在循环控制上既保留了传统语言的经典写法，又引入了许多简洁、安全的语法特性。本文将从基础语法出发，结合丰富的代码实例，系统讲解 Kotlin 中的循环控制方式，帮助读者在实际开发中写出更优雅、更高效的循环代码。

2. 基础循环：for、while 与 do-while

Kotlin 提供了三种基本的循环结构：for、while和do-while。其中for循环主要用于遍历集合或区间，while和do-while则适用于条件控制的场景。

2.1 for 循环

Kotlin 的for循环可以遍历任何提供了迭代器的对象，最常见的用法是遍历区间和数组。

fun main() { // 遍历整数区间 1..5 for (i in 1..5) { println("i = $i") } // 遍历数组 val fruits = arrayOf("Apple", "Banana", "Cherry") for (fruit in fruits) { println("水果: $fruit") } // 使用索引遍历 for (index in fruits.indices) { println("索引 $index 对应的水果是 ${fruits[index]}") } // 同时获取索引和值 for ((index, fruit) in fruits.withIndex()) { println("第 $index 个水果是 $fruit") } }

运行结果：

i = 1 i = 2 i = 3 i = 4 i = 5 水果: Apple 水果: Banana 水果: Cherry 索引 0 对应的水果是 Apple 索引 1 对应的水果是 Banana 索引 2 对应的水果是 Cherry 第 0 个水果是 Apple 第 1 个水果是 Banana 第 2 个水果是 Cherry

2.2 while 循环

while循环在每次迭代前检查条件，只有条件为真时才执行循环体。

fun main() { var count = 0 while (count < 5) { println("count = $count") count++ } }

运行结果：

count = 0 count = 1 count = 2 count = 3 count = 4

2.3 do-while 循环

do-while循环与while的区别在于：它先执行一次循环体，再检查条件。因此无论条件是否成立，循环体至少会执行一次。

fun main() { var number = 10 do { println("当前值: $number") number-- } while (number > 7) }

运行结果：

当前值: 10 当前值: 9 当前值: 8

3. 区间与步长控制

Kotlin 的区间（Range）是循环控制的重要工具，通过..、downTo、step等操作符可以灵活控制循环的范围和步长。

3.1 正向区间与反向区间

fun main() { // 正向区间 1..5，包含两端 for (i in 1..5) { print("$i ") } println() // 反向区间 5 downTo 1，包含两端 for (i in 5 downTo 1) { print("$i ") } println() // 左开右闭区间 until，不包含结束值 for (i in 1 until 5) { print("$i ") } println() }

运行结果：

1 2 3 4 5 5 4 3 2 1 1 2 3 4

3.2 使用 step 控制步长

fun main() { // 步长为 2，输出 1 3 5 for (i in 1..5 step 2) { print("$i ") } println() // 反向步长，输出 10 8 6 4 2 for (i in 10 downTo 1 step 2) { print("$i ") } println() // 浮点区间（使用 step 需注意精度） for (i in 0.0..1.0 step 0.25) { print("$i ") } println() }

运行结果：

1 3 5 10 8 6 4 2 0.0 0.25 0.5 0.75 1.0

4. 循环控制语句：break 与 continue

break用于立即终止整个循环，continue用于跳过当前迭代、进入下一次循环。两者都可以配合标签（Label）实现更精确的控制。

4.1 break 与 continue 基础用法

fun main() { // break：找到第一个偶数后终止循环 for (i in 1..10) { if (i % 2 == 0) { println("找到第一个偶数: $i") break } } // continue：跳过奇数，只输出偶数 for (i in 1..10) { if (i % 2 != 0) { continue } print("$i ") } println() }

运行结果：

找到第一个偶数: 2 2 4 6 8 10

4.2 标签与嵌套循环

在嵌套循环中，普通的break只能跳出最内层循环。使用标签可以跳出指定层级的循环。

fun main() { // 使用标签跳出外层循环 outer@ for (i in 1..3) { for (j in 1..3) { if (i == 2 && j == 2) { println("命中 (i=$i, j=$j)，跳出外层循环") break@outer } println("i=$i, j=$j") } } println("--- 分割线 ---") // 使用标签 continue 跳过外层循环的当前迭代 outer@ for (i in 1..3) { for (j in 1..3) { if (j == 2) { println("跳过外层 i=$i 的剩余迭代") continue@outer } println("i=$i, j=$j") } } }

运行结果：

i=1, j=1 i=1, j=2 i=1, j=3 i=2, j=1 命中 (i=2, j=2)，跳出外层循环 --- 分割线 --- i=1, j=1 跳过外层 i=1 的剩余迭代 i=2, j=1 跳过外层 i=2 的剩余迭代 i=3, j=1 跳过外层 i=3 的剩余迭代

5. 遍历集合的高级用法

Kotlin 标准库为集合遍历提供了丰富的扩展函数，这些函数往往比传统的for循环更简洁、更安全。

5.1 forEach 与 forEachIndexed

fun main() { val numbers = listOf(10, 20, 30, 40) // forEach 遍历 numbers.forEach { number -> println("值: $number") } // forEachIndexed 同时获取索引 numbers.forEachIndexed { index, number -> println("索引 $index 的值是 $number") } }

运行结果：

值: 10 值: 20 值: 30 值: 40 索引 0 的值是 10 索引 1 的值是 20 索引 2 的值是 30 索引 3 的值是 40

5.2 遍历 Map

fun main() { val scores = mapOf("Alice" to 90, "Bob" to 85, "Charlie" to 95) // 遍历键值对 for ((name, score) in scores) { println("$name 的分数是 $score") } // 使用 forEach 遍历 scores.forEach { (name, score) -> println("$name: $score") } // 只遍历键或值 for (name in scores.keys) { println("学生: $name") } for (score in scores.values) { println("分数: $score") } }

运行结果：

Alice 的分数是 90 Bob 的分数是 85 Charlie 的分数是 95 Alice: 90 Bob: 85 Charlie: 95 学生: Alice 学生: Bob 学生: Charlie 分数: 90 分数: 85 分数: 95

6. 实战案例：综合运用循环控制

下面通过两个完整的实战案例，展示循环控制在真实场景中的综合运用。

6.1 案例一：打印九九乘法表

fun main() { for (i in 1..9) { for (j in 1..i) { print("$j x $i = ${i * j}\t") } println() } }

运行结果：

1 x 1 = 1 1 x 2 = 2 2 x 2 = 4 1 x 3 = 3 2 x 3 = 6 3 x 3 = 9 1 x 4 = 4 2 x 4 = 8 3 x 4 = 12 4 x 4 = 16 1 x 5 = 5 2 x 5 = 10 3 x 5 = 15 4 x 5 = 20 5 x 5 = 25 1 x 6 = 6 2 x 6 = 12 3 x 6 = 18 4 x 6 = 24 5 x 6 = 30 6 x 6 = 36 1 x 7 = 7 2 x 7 = 14 3 x 7 = 21 4 x 7 = 28 5 x 7 = 35 6 x 7 = 42 7 x 7 = 49 1 x 8 = 8 2 x 8 = 16 3 x 8 = 24 4 x 8 = 32 5 x 8 = 40 6 x 8 = 48 7 x 8 = 56 8 x 8 = 64 1 x 9 = 9 2 x 9 = 18 3 x 9 = 27 4 x 9 = 36 5 x 9 = 45 6 x 9 = 54 7 x 9 = 63 8 x 9 = 72 9 x 9 = 81

6.2 案例二：筛选质数

fun main() { val limit = 50 val primes = mutableListOf<Int>() for (num in 2..limit) { var isPrime = true for (divisor in 2 until num) { if (num % divisor == 0) { isPrime = false break } } if (isPrime) { primes.add(num) } } println("1 到 $limit 之间的质数: $primes") }

运行结果：

1 到 50 之间的质数: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

7. 循环中的常见陷阱与最佳实践

在使用循环时，有一些常见的陷阱需要特别注意，同时也有一些最佳实践可以帮助写出更健壮的代码。

7.1 常见陷阱

• 无限循环：忘记更新循环变量或条件永远为真，会导致程序卡死。例如while (true)且没有break出口。
• 区间边界混淆：1..5包含 5，而1 until 5不包含 5，混用容易导致边界错误。
• 在循环中修改集合：遍历List时直接调用add或remove可能抛出ConcurrentModificationException，应使用迭代器或先收集再修改。
• 浮点步长精度问题：使用浮点数作为步长时可能产生精度误差，建议使用整数索引或BigDecimal。

7.2 最佳实践

• 优先使用区间和集合函数：能用for (i in 1..10)就不要手写while加计数器。
• 善用forEach等函数式遍历：代码更简洁，且天然避免索引越界问题。
• 使用标签时保持代码可读：标签命名要有意义，避免滥用导致逻辑混乱。
• 循环体尽量短小：过长的循环体应拆分为独立函数，提升可读性和可测试性。
• 注意break和continue的使用场景：能用条件判断替代时，优先使用条件判断，减少控制流跳转。

8. 总结

本文系统介绍了 Kotlin 循环控制的各个方面：从基础的for、while、do-while循环，到区间与步长控制，再到break、continue和标签的高级用法，最后通过实战案例展示了循环在真实场景中的应用。掌握这些知识后，读者可以在日常开发中根据具体场景选择最合适的循环方式，写出既高效又易读的 Kotlin 代码。