流程控制

分支结构

Kotlin 提供了两种常见的分支控制结构: if分支和 when 分支 。其中 if分支使用布尔表达式或布尔值作为分支条件来进行分支控制;而 when 分支则更适用于复杂的条件。一般来说，当条件较为简单且可能的情况很少时，使用 if 分支;当条件比较复杂且可能的情况很多时，可以考虑使用 when分支。

if分支

Kotlin 的 if语句的形式。

if (expression) {
statements ...
else if (expression) {
statements ...
}
... //可以有零个或多个 else if语句
else{
statements ...
}

if表达式

Kotlin 的 if分支还可作为表达式使用。也就是说，整个if表达式(包括 else 部分)最终会返回一个值，如果没返回值，则返回kotlin.Unit。因此 if可以代替 Java 中的三目运算符。

fun main(args: Array) {
    var age = 18
    //将 if 表达式赋值给 str 变量
    var str = if (age > 20)
        "age大于20"
    else if (age < 20) {
        println("小于哦")
        "age小于20"
    } else
        "age等于20"
    println(str)
}

when分支

when 分支取代了 Java 原有的 switch 语句,when 分支后的值不再要求是常量或字面值，可以是任意表达式 。

fun main(args: Array) {
    var score = 'B'
    var str = "EFGH"
    when (score) {
        'A' -> println("优秀")
        'B' -> {
            println("一般般优秀")
        }
        'C', 'D' -> println("差了点")
        str[0] - 5 -> println("对不起，打扰了！")
        else -> {
            println("需要努力了")
        }
    }
}

when分支不再对条件表达式的类型有任何要求， when分支的条件表达式可以是任意类型 。 例如,只要 when 的条件表达式与某个分支的值通过“==”比较返回 true，就能执行该分支的代码

fun main(args: Array) {
    var date = Date()
    //when 分支的条件表达式是 Date 类型 
    when (date) {
        Date() -> {
            println("优秀")
            println("望百尺竿头更进一步")
        }
        else -> {
            println("不优秀")
        }
    }
    
}

when表达式

与 if分支相同， when分支也可作为表达式。
如果 when 分支被当作表达式，那么符合条件的分支的代码块的值就是整个表达式的值。 与 if 分支相同的是，如果分支的执行体是一个代码块，那么该代码块的值就是块中最后的表达式的值 。当 when语句作为表达式使用时， when表达式也需要有一个返回值，因此 when表达式通常必须有 else分支，除非编译器能够检测出所有的可能情况都己经被覆盖了。

fun main(args: Array) {
    var score ='b'
    var str = when(score){
        'A' ->{
            println("优秀")
            "AAAA"
        }
        'B' ->{
            println("良")
            "BBBB"
        }
        else ->{
            println("没救了")
            "DDDD"
        }
    }

    println(str)
}

when 分支处理范围

通过使用 in、 !in 运算符，我们还可以使用 when 分支检查表达式是否位于指定区间或集合中 。 例如:

fun main(args: Array) {
    var age =Random().nextInt(100)
    println(age)
    var str = when(age){
        in 10..25 ->{
            println("优秀")
            "AAAA"
        }
        in 25..90 ->{
            println("良")
            "BBBB"
        }
        else ->{
            println("没救了")
            "DDDD"
        }
    }

    println(str)
}

when分支处理类型

通过使用 is、!is 运算符，我们还可以使用 when 分支检查表达式是否为指定类型 。例如：

fun main(args: Array) {
    var inputPrice = 26
    println(realPrice(inputPrice))
}
//程序对 inputPrice 的类型进行判断
fun realPrice(intputPrice:Any)=when(intputPrice){
    //如果 inputPrice 的类型为 String， 程序返回该字符串转换的 Double 值
    is String -> intputPrice.toDouble()
    //如果 inputPrice 的类型为 Int，程序返回该 Int 值转换的 Double 值
    is Int -> intputPrice.toDouble()
    is Double -> intputPrice
    else ->0.0
}

when条件分支

when分支还可以用来取代 if...else if链，此时不需要为 when分支提供任何条件表达式， 每个分支条件都是一个布尔表达式，当指定分支的布尔表达式为 true 时执行该分支。例如：

fun main(args: Array) {
    var inputPrice = "11"
    when{
        inputPrice.matches(Regex("\\d+")) -> println("全是数字")
        inputPrice.matches(Regex("[a-zA-Z]+")) -> println("全是字母")
        inputPrice.matches(Regex("[a-zA-Z0-9]+")) -> println("数字和字母")
        else -> println("您输入的包含特殊字符")
    }
}

循环结构

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体。当反复执行这个循环体时 ， 需要在合适的时候把循环条件改为假，从而结束循环; 否则循环将一直执行下去，形成死循环。

while循环

while 循环的语法格式如下:

[init statements)
while test expression {
body_statements [iteration statements)
}

fun main(args: Array) {
    var inputPrice = 0
    while (inputPrice<10){
        println(inputPrice)
        inputPrice++
    }
}

do while循环

do while 循环与 while 循环的区别在于: while 循环是先判断循环条件，如果条件为真则执行循环体;而 do while 循环则先执行循环体，然后才判断循环条件，如果循环条件为真，则执行下一次循环 ，否则中止循环。do while 循环的循环体至少执行一次。do while 循环的语法格式如下:

[init statements] do
body statements [iteration statements]
}while (test expression)

fun main(args: Array) {
    var inputPrice = 0
    do {
        println(inputPrice)
        inputPrice++
    }while (inputPrice<10)
}

for-in循环

for-in 循环专门用于遍历范围、序列和集合等包含的元素。for-in 循环的语法格式如下:

for (常量名 in 字符串|范围|集合){
statements
}

对于上面语法格式有两点说明。

• for-in 循环中的常量无须声明。 for-in 循环中的常量将会在每次循环开始时自动被赋值，因此该常量无须提前声明。只要将它包含在 for-in 循环的声明中，即可隐式声明该常量，无须使用 let关键字声明。
• for-in循环可用于遍历任何可迭代对象。所谓可选代对象就是该对象包含一个 iterator() 方法，且该方法的返回值对象具有 next()、 hasNext()方法，这三个方法都使用 operator 修饰。

fun main(args: Array) {
    var max = 7
    var result = 1
    //使用 for-in循环遍历范围
    for (num in 1..max) {
        result *= num
        println(result)
    }
}

嵌套循环

fun main(args: Array) {
    //外层循环
    for(i in 0 until 5){
        var j = 0
        //内层循环
        while( j <3 ) {
            println(j)
            j++
        }
    }
}

控制循环结构

Kotlin 语言没有提供 goto 语句来控制程序的跳转，这种做法提高了程序流程控制的可读性，但降低了其灵活性。为了弥补这种不足，Kotlin提供了continue和 break来控制循环结构。除此之外，使用 return 可以结束整个方法，当然也就结束了一次循环 。

使用 break结束循环

某些时候，需要在某种条件出现时强行中止循环，而不是等到循环条件为 false时才退出循环 。 此时，可以使用 break来完成这个功能。break 用于完全结束一个循环，跳出循环体 。 不管是哪种循环， 一旦在循环体中遇到break，系统将完全结束该循环，开始执行循环之后的代码。 例如:

fun main(args: Array) {
    //外层循环
    for (i in 0 until 5) {
        println(i)
        if (i == 2) {
            break
        }
    }
}

使用 break 语句不仅可以结束其所在的循环，还可以直接结束其外层循环 。此时需要在 break 后紧跟一个标签，这个标签用于标识一个外层循环 。
Kotlin 中的标签就是一个紧跟着@的标识符。 Kotlin 中的标签只有放在循环语句或 switch 语句之前才起作用。例如下面代码。

fun main(args: Array) {
    //外层循环， outer 作为标识符
    outer@ for (i in 0 until 5) {
        //内层循环
        for (j in 0 until 3) {
            println("i的值为:${i}, j的值为:${j}")
            if(j==1){
                //跳出 outer 标签所标识的循环
                break@outer
            }

        }
    }
}

break 后的标签必须是一个有效的标签，即这个标签必须在 break 语句所 在的循环之前定义，或者在其所在循环的外层循环之前定义。

使用 continue 忽略本次循环的剩下语句

continue 的功能和 break有点类似，区别是 continue 只是忽略本次循环的剩下语句，接着开始下一次循环，并不会中止循环;而 break则是完全中止循环本身。如下:

fun main(args: Array) {
   for (i in 0 until 5) {
       println(i)
       if(i==2){
           continue
       }
       println("continue之后的语句")
  }
}

与 break 类似的是，continue 后也可以紧跟一个标签，用于直接跳过标签所标识循环的当次循环的剩下语句 ，重新开始下一次循环。例如:

fun main(args: Array) {
    //外层循环， outer 作为标识符
    outer@ for (i in 0 until 5) {
        //内层循环
        for (j in 0 until 3) {
            println("i的值为:${i}, j的值为:${j}")
            if(j==1){
                //忽略 outer 标签所指定的循环中当次循环剩下的语句
                continue@outer
            }

        }
    }
}

使用 return 结束方法

return 用于从最直接包围它的方法、函数或者匿名函数返回。当函数或方法执行到一条return语句时( return 关键字后还可以跟变量、常量和表达式)，这个函数或方法将被结束。
Kotlin 程序中的大部分循环都被放在函数或方法中执行， 一旦在循环体内执行到一条 return 语句时 ， return语句就会结束该函数或方法，循环自然也随之结束 。

fun main(args: Array) {
    test()
}

fun test(){
    for (i in 0 until 5) {
        println("i的值为:${i}")
        if(i==2){
            return
        }
    }
}