Kotlin循环结构详解

Kotlin 中的 for 循环

在 Kotlin 中，for 循环是一种非常常用的循环结构，它用于遍历任何提供迭代器（Iterator）的对象。Kotlin 的 for 循环语法简洁且功能强大，支持多种类型的迭代。

基本语法

for 循环的基本语法如下：

for (item in collection) {
    // 执行的代码块，item 是每次迭代从 collection 中取出的元素
}

这里的 collection 可以是任何可迭代的对象，比如 List、Set、Map 或者自定义的实现了 Iterable 接口的类。

遍历数组和集合

遍历 List：

val numbers = listOf(1, 2, 3, 4, 5)
for (number in numbers) {
    println(number)
}

上述代码中，for 循环依次从 numbers 列表中取出每个元素并打印。

遍历 Array：

val fruits = arrayOf("apple", "banana", "cherry")
for (fruit in fruits) {
    println(fruit)
}

在这个例子里，我们遍历了一个字符串数组，依次打印出每个水果的名称。

遍历区间

Kotlin 中的区间是一种很方便的结构，for 循环可以很容易地遍历区间。 遍历整数区间：

for (i in 1..5) {
    println(i)
}

这里 1..5 表示从 1 到 5 的闭区间，for 循环会依次迭代 i 为 1、2、3、4、5。

如果要遍历递减的区间，可以使用 downTo 关键字：

for (i in 5 downTo 1) {
    println(i)
}

此代码会从 5 递减到 1 依次打印。

还可以在遍历区间时指定步长，使用 step 关键字：

for (i in 1..10 step 2) {
    println(i)
}

上述代码中，步长为 2，所以会打印 1、3、5、7、9。

遍历字符区间

for 循环也可以遍历字符区间：

for (c in 'a'..'e') {
    println(c)
}

这段代码会依次打印 a、b、c、d、e。

使用索引遍历集合

有时候我们不仅需要集合中的元素，还需要元素的索引。在 Kotlin 中，可以使用 withIndex() 函数来实现：

val colors = listOf("red", "green", "blue")
for ((index, color) in colors.withIndex()) {
    println("Index $index: $color")
}

withIndex() 函数返回一个包含索引和元素的 IndexedValue 对象，我们可以通过解构声明分别获取索引 index 和元素 color。

Kotlin 中的 while 循环

while 循环是 Kotlin 中另一种常用的循环结构，它基于一个条件来决定是否继续循环。只要条件为真，循环体就会一直执行。

基本语法

while 循环的基本语法如下：

while (condition) {
    // 循环体代码，当 condition 为 true 时执行
}

其中 condition 是一个布尔表达式，每次循环开始时都会检查该表达式的值。

示例

var count = 0
while (count < 5) {
    println("Count is $count")
    count++
}

在这个例子中，count 初始值为 0，只要 count 小于 5，循环体就会执行，每次循环 count 自增 1。当 count 达到 5 时，条件 count < 5 为假，循环结束。

无限循环

可以通过设置一个永远为真的条件来创建无限循环：

while (true) {
    println("This is an infinite loop. Press Ctrl + C to stop.")
}

这种无限循环在实际应用中通常用于需要持续运行的程序，比如服务器程序监听端口等，但要注意在适当的时候提供退出机制，否则程序将无法停止。

Kotlin 中的 do - while 循环

do - while 循环与 while 循环类似，但有一个重要的区别：do - while 循环会先执行一次循环体，然后再检查条件。

基本语法

do - while 循环的基本语法如下：

do {
    // 循环体代码，先执行一次
} while (condition)

condition 同样是一个布尔表达式，在循环体执行后检查。如果条件为真，循环继续；否则，循环结束。

示例

var number = 0
do {
    println("Number is $number")
    number++
} while (number < 3)

在这个例子中，即使初始时 number 为 0，循环体也会先执行一次，打印出 Number is 0。然后 number 自增为 1，检查条件 number < 3 为真，继续循环，再次打印并自增，直到 number 变为 3，条件为假，循环结束。

循环控制语句

在 Kotlin 的循环结构中，有几个重要的控制语句，如 break、continue 和 return，它们可以改变循环的正常执行流程。

break 语句

break 语句用于立即终止循环。无论循环条件是否满足，只要执行到 break，循环就会结束。

在 for 循环中使用 break：

val numbers = listOf(1, 2, 3, 4, 5)
for (number in numbers) {
    if (number == 3) {
        break
    }
    println(number)
}

上述代码会打印 1 和 2，当 number 等于 3 时，执行 break 语句，循环终止，不再打印 4 和 5。

在 while 循环中使用 break：

var count = 0
while (count < 5) {
    if (count == 2) {
        break
    }
    println("Count is $count")
    count++
}

此 while 循环会打印 Count is 0 和 Count is 1，当 count 变为 2 时，break 终止循环。

continue 语句

continue 语句用于跳过当前循环的剩余部分，直接进入下一次循环。

在 for 循环中使用 continue：

val numbers = listOf(1, 2, 3, 4, 5)
for (number in numbers) {
    if (number % 2 == 0) {
        continue
    }
    println(number)
}

这里，当 number 是偶数时，执行 continue，跳过 println 语句，直接进入下一次循环。所以只会打印 1、3、5。

在 while 循环中使用 continue：

var count = 0
while (count < 5) {
    count++
    if (count == 3) {
        continue
    }
    println("Count is $count")
}

在这个 while 循环中，当 count 等于 3 时，执行 continue，跳过 println 语句，直接进入下一次循环，所以不会打印 Count is 3。

return 语句

return 语句通常用于从函数中返回值，但在嵌套循环中，它也可以用于终止整个函数的执行，从而间接终止循环。

fun findFirstEven(numbers: List<Int>) {
    for (number in numbers) {
        if (number % 2 == 0) {
            println("First even number: $number")
            return
        }
    }
    println("No even number found.")
}

在这个函数中，当找到第一个偶数时，打印该偶数并使用 return 终止函数，循环也随之结束。如果遍历完整个列表都没有找到偶数，则打印提示信息。

嵌套循环

在 Kotlin 中，可以在一个循环内部再嵌套另一个循环，这种结构称为嵌套循环。

嵌套 for 循环

for (i in 1..3) {
    for (j in 1..3) {
        println("$i * $j = ${i * j}")
    }
}

在这个例子中，外层 for 循环控制 i 的值从 1 到 3，对于每一个 i 的值，内层 for 循环控制 j 的值从 1 到 3，并打印乘法表。

嵌套 while 循环

var outerCount = 0
while (outerCount < 2) {
    var innerCount = 0
    while (innerCount < 3) {
        println("Outer: $outerCount, Inner: $innerCount")
        innerCount++
    }
    outerCount++
}

这里外层 while 循环控制 outerCount 从 0 到 1，对于每一个 outerCount 的值，内层 while 循环控制 innerCount 从 0 到 2，并打印外层和内层循环变量的值。

混合嵌套循环

也可以混合使用不同类型的循环进行嵌套：

for (i in 1..2) {
    var j = 1
    while (j <= 2) {
        println("$i, $j")
        j++
    }
}

在这个例子中，外层是 for 循环，内层是 while 循环，通过这种混合嵌套实现特定的循环逻辑。

循环性能优化

在使用循环时，性能是一个需要考虑的重要因素。以下是一些在 Kotlin 中优化循环性能的方法。

使用合适的数据结构

选择合适的数据结构可以显著提高循环性能。例如，如果需要频繁插入和删除元素，LinkedList 可能比 ArrayList 更合适；但如果主要是随机访问，ArrayList 性能更好。

减少循环体内的计算

尽量将循环体内的不变计算移到循环外部。

// 不好的做法
for (i in 1..1000) {
    val result = expensiveCalculation() * 2
    println(result)
}

// 好的做法
val factor = 2
for (i in 1..1000) {
    val result = expensiveCalculation() * factor
    println(result)
}

在第一个例子中，expensiveCalculation() * 2 每次循环都计算一次；而在第二个例子中，将 2 提取到循环外，减少了重复计算。

使用索引访问集合

如果需要通过索引访问集合元素，直接使用 list[index] 比使用迭代器性能更好，尤其是对于 ArrayList。

val list = ArrayList<Int>()
for (i in 0 until list.size) {
    val element = list[i]
    // 处理 element
}

而不是：

val list = ArrayList<Int>()
for (element in list) {
    // 处理 element
}

不过这种方式在使用 LinkedList 时性能可能反而更差，因为 LinkedList 的随机访问性能不佳。

自定义迭代器

在 Kotlin 中，我们可以为自定义类提供迭代器，从而使该类能够在 for 循环中使用。

实现 Iterable 接口

要使自定义类可迭代，需要实现 Iterable 接口，并提供一个 iterator() 方法。

class MyCollection<T> : Iterable<T> {
    private val elements = mutableListOf<T>()

    fun add(element: T) {
        elements.add(element)
    }

    override fun iterator(): Iterator<T> {
        return elements.iterator()
    }
}

fun main() {
    val collection = MyCollection<Int>()
    collection.add(1)
    collection.add(2)
    collection.add(3)

    for (element in collection) {
        println(element)
    }
}

在这个例子中，MyCollection 类实现了 Iterable 接口，其 iterator() 方法返回内部 MutableList 的迭代器，这样就可以在 for 循环中遍历 MyCollection 的元素。

自定义迭代器逻辑

我们也可以自定义迭代器的逻辑，而不是简单地使用已有的集合迭代器。

class MyIterator<T> : Iterator<T> {
    private val elements = mutableListOf<T>()
    private var index = 0

    fun add(element: T) {
        elements.add(element)
    }

    override fun hasNext(): Boolean {
        return index < elements.size
    }

    override fun next(): T {
        if (!hasNext()) {
            throw NoSuchElementException()
        }
        return elements[index++]
    }
}

class MyCustomCollection<T> : Iterable<T> {
    private val myIterator = MyIterator<T>()

    fun add(element: T) {
        myIterator.add(element)
    }

    override fun iterator(): Iterator<T> {
        return myIterator
    }
}

fun main() {
    val customCollection = MyCustomCollection<Int>()
    customCollection.add(1)
    customCollection.add(2)
    customCollection.add(3)

    for (element in customCollection) {
        println(element)
    }
}

这里 MyIterator 类自定义了迭代逻辑，MyCustomCollection 使用这个自定义迭代器，使得在 for 循环中遍历该集合时按照自定义的方式进行。

与其他编程语言循环结构的对比

与 Java 的对比

• 语法简洁性：Kotlin 的 for 循环语法更简洁。例如，在 Java 中遍历数组需要使用传统的 for 循环或者 foreach 语法，而 Kotlin 直接使用 for (item in array) 这种简洁的语法。

// Java 遍历数组
int[] numbers = {1, 2, 3};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]);
}

// Java foreach 遍历数组
for (int number : numbers) {
    System.out.println(number);
}

// Kotlin 遍历数组
val numbers = intArrayOf(1, 2, 3)
for (number in numbers) {
    println(number)
}

• 区间遍历：Kotlin 对区间遍历的支持更方便，如 1..5 这样的语法在 Java 中需要手动实现类似功能。

与 Python 的对比

• 类型声明：Kotlin 是静态类型语言，在循环中变量的类型在编译时就确定；而 Python 是动态类型语言，变量类型在运行时确定。这使得 Kotlin 在循环性能和类型安全性上有一定优势。

# Python 遍历列表
numbers = [1, 2, 3]
for number in numbers:
    print(number)

// Kotlin 遍历列表
val numbers = listOf(1, 2, 3)
for (number in numbers) {
    println(number)
}

• 循环控制语句：Kotlin 和 Python 都有 break 和 continue 语句，但在使用场景和语法细节上可能略有不同。例如，Python 中没有像 Kotlin 那样在嵌套循环中直接使用 return 来终止整个函数（间接终止循环）的常见用法。

循环在实际项目中的应用场景

数据处理

在数据处理场景中，循环经常用于遍历数据集进行计算、过滤等操作。例如，在处理一个用户列表，计算所有用户的平均年龄：

data class User(val name: String, val age: Int)

fun calculateAverageAge(users: List<User>): Double {
    var totalAge = 0
    for (user in users) {
        totalAge += user.age
    }
    return if (users.isNotEmpty()) totalAge.toDouble() / users.size else 0.0
}

fun main() {
    val users = listOf(
        User("Alice", 25),
        User("Bob", 30),
        User("Charlie", 35)
    )
    val averageAge = calculateAverageAge(users)
    println("Average age: $averageAge")
}

图形绘制

在图形绘制相关的项目中，循环可用于绘制重复的图形元素。例如，绘制一个由多个矩形组成的图案：

import javax.swing.*
import java.awt.*

class MyPanel : JPanel() {
    override fun paintComponent(g: Graphics) {
        super.paintComponent(g)
        for (i in 0 until 5) {
            for (j in 0 until 5) {
                g.drawRect(i * 50, j * 50, 40, 40)
            }
        }
    }
}

fun main() {
    val frame = JFrame("Drawing with Loops")
    frame.defaultCloseOperation = JFrame.EXIT_ON_CLOSE
    frame.add(MyPanel())
    frame.setSize(300, 300)
    frame.setVisible(true)
}

游戏开发

在游戏开发中，循环可用于处理游戏逻辑，如更新游戏角色的位置、检测碰撞等。例如，一个简单的贪吃蛇游戏中更新蛇的位置：

data class Point(val x: Int, val y: Int)

class Snake {
    private var body = mutableListOf(Point(50, 50), Point(40, 50), Point(30, 50))

    fun move() {
        // 简单的移动逻辑，省略方向控制等细节
        for (i in body.size - 1 downTo 1) {
            body[i] = body[i - 1]
        }
        body[0] = Point(body[0].x + 10, body[0].y)
    }
}

通过深入理解 Kotlin 的循环结构，包括 for 循环、while 循环、do - while 循环以及循环控制语句等，并掌握相关的性能优化和实际应用场景，开发者能够更加高效地编写 Kotlin 程序，解决各种实际问题。无论是简单的数据处理，还是复杂的图形绘制和游戏开发，循环结构都是 Kotlin 编程中不可或缺的重要部分。同时，与其他编程语言循环结构的对比，也有助于开发者更好地理解 Kotlin 循环的特点和优势，在不同场景下做出更合适的选择。