Skip to content

控制流 ​

与其他编程语言一样,Kotlin 能够根据一段代码的求值结果是否为 true 来做出决策。这类代码被称为条件表达式。Kotlin 还能够创建并遍历循环。

条件表达式 ​

Kotlin 提供了 if 和 when 来检查条件表达式。

如果你需要在 if 和 when 之间做出选择,我们建议使用 when,因为它可以:

  • 使代码更易于阅读。
  • 更易于添加其他分支。
  • 减少代码中的错误。

If ​

若要使用 if,请将条件表达式置于圆括号 () 内,并将结果为 true 时要执行的操作置于花括号 {} 内:

kotlin
fun main() {
    val d: Int
    val check = true

    if (check) {
        d = 1
    } else {
        d = 2
    }

    println(d)
    // 1
}

Kotlin 中没有三元运算符 condition ? then : else。取而代之的是,if 可以用作表达式。如果每个操作只有一行代码,花括号 {} 是可选的:

kotlin
fun main() { 
    val a = 1
    val b = 2

    println(if (a > b) a else b) // 返回一个值:2
}

When ​

当条件表达式包含多个分支时,请使用 when。

若要使用 when:

  • 将要计算的值置于圆括号 () 内。
  • 将分支置于花括号 {} 内。
  • 在每个分支中使用 -> 将每次检查与检查成功后要执行的操作分隔开。

when 既可以用作语句,也可以用作表达式。语句不返回任何内容,而是执行操作。

以下是将 when 用作语句的示例:

kotlin
fun main() {
    val obj = "Hello"

    when (obj) {
        // 检查 obj 是否等于 "1"
        "1" -> println("One")
        // 检查 obj 是否等于 "Hello"
        "Hello" -> println("Greeting")
        // 默认语句
        else -> println("Unknown")     
    }
    // Greeting
}

请注意,所有分支条件都会按顺序进行检查,直到满足其中一个条件为止。因此,只有第一个符合条件的分支会被执行。

表达式会返回一个可以在后续代码中使用的值。

以下是将 when 用作表达式的示例。when 表达式会立即赋值给一个变量,该变量随后用于 println() 函数:

kotlin
fun main() {
    val obj = "Hello"    
    
    val result = when (obj) {
        // 如果 obj 等于 "1",则将 result 设置为 "One"
        "1" -> "One"
        // 如果 obj 等于 "Hello",则将 result 设置为 "Greeting"
        "Hello" -> "Greeting"
        // 如果前面的条件均不满足,则将 result 设置为 "Unknown"
        else -> "Unknown"
    }
    println(result)
    // Greeting
}

到目前为止你所看到的 when 示例都有一个主体:obj。但 when 也可以在没有主体的情况下使用。

本例使用没有主体的 when 表达式来检查一系列布尔表达式:

kotlin
fun main() {
    val trafficLightState = "Red" // 可以是 "Green"、"Yellow" 或 "Red"

    val trafficAction = when {
        trafficLightState == "Green" -> "Go"
        trafficLightState == "Yellow" -> "Slow down"
        trafficLightState == "Red" -> "Stop"
        else -> "Malfunction"
    }

    println(trafficAction)
    // Stop
}

不过,你也可以编写同样的代码,但将 trafficLightState 作为主体:

kotlin
fun main() {
    val trafficLightState = "Red" // 可以是 "Green"、"Yellow" 或 "Red"

    val trafficAction = when (trafficLightState) {
        "Green" -> "Go"
        "Yellow" -> "Slow down"
        "Red" -> "Stop"
        else -> "Malfunction"
    }

    println(trafficAction)  
    // Stop
}

带有主体的 when 可以使代码更易于阅读和维护。当你在 when 表达式中使用主体时,它还有助于 Kotlin 检查是否涵盖了所有可能的情况。否则,如果不在 when 表达式中使用主体,则需要提供 else 分支。

练习:条件表达式 ​

检查掷两次骰子的结果是否匹配

创建一个简单的小游戏:如果投掷两次骰子得到相同的点数,则获胜。如果骰子点数匹配,使用 if 打印 You win :);否则打印 You lose :(。

在本练习中,你将导入一个软件包,以便使用 Random.nextInt() 函数获取随机 Int。 有关导入软件包的更多信息,请参阅软件包和导入。

提示
使用相等运算符(==)比较骰子结果。
kotlin
import kotlin.random.Random

fun main() {
    val firstResult = Random.nextInt(6)
    val secondResult = Random.nextInt(6)
    // 在此处编写你的代码
}
示例解决方案 {...}
kotlin
import kotlin.random.Random

fun main() {
    val firstResult = Random.nextInt(6)
    val secondResult = Random.nextInt(6)
    if (firstResult == secondResult)
        println("You win :)")
    else
        println("You lose :(")
}
打印游戏手柄按钮对应的操作

使用 when 表达式更新以下程序,使其打印表中任意游戏手柄按钮对应的操作。button 的初始值为 "A",但你可以更改它来尝试其他按钮。

按钮操作
AYes
BNo
XMenu
YNothing
OtherThere is no such button
kotlin
var button = "A"

fun main() {
    println(
        // 在此处编写你的代码
    )
}
示例解决方案 {...}
kotlin
var button = "A"

fun main() {
    println(
        when (button) {
            "A" -> "Yes"
            "B" -> "No"
            "X" -> "Menu"
            "Y" -> "Nothing"
            else -> "There is no such button"
        }
    )
}

区间 ​

在讨论循环之前,了解如何构建供循环遍历的区间会很有帮助。

在 Kotlin 中创建区间最常见的方法是使用 .. 运算符。例如,1..4 等同于 1, 2, 3, 4。

要声明不包含末尾值的区间,请使用 ..< 运算符。例如,1..<4 等同于 1, 2, 3。

要以倒序声明区间,请使用 downTo。例如,4 downTo 1 等同于 4, 3, 2, 1。

要声明步长不为 1 的递增区间,请使用 step 和所需的增量值。 例如,1..5 step 2 等同于 1, 3, 5。

对于 Char 区间,也可以执行相同的操作:

  • 'a'..'d' 等同于 'a', 'b', 'c', 'd'
  • 'z' downTo 's' step 2 等同于 'z', 'x', 'v', 't'

循环 ​

编程中最常见的两种循环结构是 for 和 while。使用 for 遍历一系列值并执行操作。使用 while 持续执行操作,直到满足特定条件为止。

For ​

利用刚刚学到的区间知识,你可以创建一个 for 循环来遍历数字 1 到 5,并每次打印该数字。

将迭代器和区间置于带有关键字 in 的圆括号 () 内。将要完成的操作置于花括号 {} 内:

kotlin
fun main() {
    for (number in 1..5) { 
        // number 是迭代器,1..5 是区间
        print(number)
    }
    // 12345
}

集合也可以通过循环进行遍历:

kotlin
fun main() { 
    val cakes = listOf("carrot", "cheese", "chocolate")

    for (cake in cakes) {
        println("Yummy, it's a $cake cake!")
    }
    // Yummy, it's a carrot cake!
    // Yummy, it's a cheese cake!
    // Yummy, it's a chocolate cake!
}

While ​

while 可以通过两种方式使用:

  • 当条件表达式为 true 时执行代码块。(while)
  • 先执行代码块,然后再检查条件表达式。(do-while)

在第一种用例(while)中:

  • 在圆括号 () 内声明供 while 循环继续执行的条件表达式。
  • 在花括号 {} 内添加要完成的操作。

以下示例使用递增运算符 ++ 来递增 cakesEaten 变量的值。

kotlin
fun main() {
    var cakesEaten = 0
    while (cakesEaten < 3) {
        println("Eat a cake")
        cakesEaten++
    }
    // Eat a cake
    // Eat a cake
    // Eat a cake
}

在第二种用例(do-while)中:

  • 在圆括号 () 内声明供 while 循环继续执行的条件表达式。
  • 使用关键字 do 在花括号 {} 内定义要完成的操作。
kotlin
fun main() {
    var cakesEaten = 0
    var cakesBaked = 0
    while (cakesEaten < 3) {
        println("Eat a cake")
        cakesEaten++
    }
    do {
        println("Bake a cake")
        cakesBaked++
    } while (cakesBaked < cakesEaten)
    // Eat a cake
    // Eat a cake
    // Eat a cake
    // Bake a cake
    // Bake a cake
    // Bake a cake
}

有关条件表达式和循环的更多信息与示例,请参阅条件与循环。

现在你已经掌握了 Kotlin 控制流的基础知识,接下来可以学习如何编写自己的函数。

练习:循环 ​

使用 while 和 do-while 循环计算披萨切片数

你有一个程序用来计算披萨切片数,直到凑齐一整张包含 8 块切片的披萨。请通过以下两种方式重构该程序:

  • 使用 while 循环。
  • 使用 do-while 循环。
kotlin
fun main() {
    var pizzaSlices = 0
    // 从此处开始重构
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    println("There's only $pizzaSlices slice/s of pizza :(")
    pizzaSlices++
    // 在此处结束重构
    println("There are $pizzaSlices slices of pizza. Hooray! We have a whole pizza! :D")
}
示例解决方案 1 {...}
kotlin
fun main() {
    var pizzaSlices = 0
    while ( pizzaSlices < 7 ) {
        pizzaSlices++
        println("There's only $pizzaSlices slice/s of pizza :(")
    }
    pizzaSlices++
    println("There are $pizzaSlices slices of pizza. Hooray! We have a whole pizza! :D")
}
示例解决方案 2 {...}
kotlin
fun main() {
    var pizzaSlices = 0
    pizzaSlices++
    do {
        println("There's only $pizzaSlices slice/s of pizza :(")
        pizzaSlices++
    } while ( pizzaSlices < 8 )
    println("There are $pizzaSlices slices of pizza. Hooray! We have a whole pizza! :D")
}
玩 Fizz buzz 游戏

编写一个模拟 Fizz buzz 游戏的程序。你的任务是按递增顺序打印从 1 到 100 的数字;如果数字能被 3 整除,则替换为单词 "fizz";如果能被 5 整除,则替换为单词 "buzz";如果能同时被 3 和 5 整除,则必须替换为单词 "fizzbuzz"。

提示 1
使用 for 循环对数字进行计数,并使用 when 表达式来决定每一步打印的内容。
提示 2
使用取模运算符(%)返回数字相除的余数。使用相等运算符(==)检查余数是否为零。
kotlin
fun main() {
    // 在此处编写你的代码
}
示例解决方案 {...}
kotlin
fun main() {
    for (number in 1..100) {
        println(
            when {
                number % 15 == 0 -> "fizzbuzz"
                number % 3 == 0 -> "fizz"
                number % 5 == 0 -> "buzz"
                else -> "$number"
            }
        )
    }
}
打印以指定字母开头的单词

你有一个单词列表。使用 for 和 if 仅打印以字母 l 开头的单词。

提示
使用 String 类型的 .startsWith() 函数。
kotlin
fun main() {
    val words = listOf("dinosaur", "limousine", "magazine", "language")
    // 在此处编写你的代码
}
示例解决方案 {...}
kotlin
fun main() {
    val words = listOf("dinosaur", "limousine", "magazine", "language")
    for (w in words) {
        if (w.startsWith("l"))
            println(w)
    }
}