Kotlin快速入门（三）——流程控制

流程控制

与Java基本类似，Kotlin提供了if和when两种分支语句，when可以替代switch且功能更强大；Kotlin提供了while、do while、for-in循环，抛弃了Java普通for循环；Kotlin同样支持break和continue来控制循环。

1. 分支结构

1. if分支语句

   与Java一致。

2. if表达式

   Kotlin新功能，if作为表达式最终会返回一个值，因此可以代替Java的三目运算符。

   fun main(args: Array<String>) {
   
       val age = 18
       val str = if (age > 20) "age大于20" else if (age < 20)
           "age小于20" else "age等于20"
       println(str)
   }
   

   如果需要执行多行语句，可以使用{}包裹，但返回值要放在最后一行。

   fun main(args: Array<String>) {
   
       val age = 18
       val str = if (age > 20) {
           println("大于20的分支")
           "age大于20"
       } else if (age < 20) {
           println("小于20的分支")
           "age小于20"
       } else {
           println("等于20的分支")
           "age等于20"
       }
       println(str)
   }
   

3. when分支语句

   • 替代Java中的switch语句。

     fun main(args: Array<String>) {
         val score = 'B'
         when (score) {
             'A' -> println("优秀")
             'B' -> println("良好")
             'C' -> println("中")
             'D' -> println("及格")
             else -> println("不及格")
         }
     }
     

     如果需要执行多行语句，可以使用{}包裹。

   • when分支可以匹配多个值。

     fun main(args: Array<String>) {
         val score = 'B'
         when (score) {
             'A', 'B' -> {
                 println("优秀")
                 println("戒骄戒躁")
             }
             'C', 'D' -> println("中")
             else -> {
                 println("不及格")
                 println("再接再厉")
             }
         }
     }
     

   • when分支后的值不要求是常量，可以是任意表达式。

     fun main(args: Array<String>) {
         val score = 'B'
         val str = "EFGH"
         when (score) {
             str[0] - 4, str[1] - 4 -> {
                 println("优秀")
                 println("戒骄戒躁")
             }
             str[2] - 4, str[3] - 4 -> println("中")
             else -> {
                 println("不及格")
                 println("再接再厉")
             }
         }
     }
     

   • when分支对条件表达式的类型没有任何要求。

     fun main(args: Array<String>) {
         val date = java.util.Date()
         when (date) {
             java.util.Date() -> {
                 println("优秀")
                 println("戒骄戒躁")
             }
             else -> {
                 println("不及格")
                 println("再接再厉")
             }
         }
     }
     

     只要when的条件表达式与某个分支的值通过==比较返回true，程序就可以执行该分支代码。

4. when表达式

   fun main(args: Array<String>) {
       val score = 'B'
       val str = when (score) {
           'A' -> {
               println("戒骄戒躁")
               "优秀"
           }
           'B' -> "良好"
           'C' -> "中"
           'D' -> "及格"
           else -> {
               println("再接再厉")
               "不及格"
           }
       }
       println(str)
   }
   

5. when分支处理范围

   使用in、!in运算符，处理范围。

   fun main(args: Array<String>) {
       val age = java.util.Random().nextInt(100)
       println(age)
       val str = when (age) {
           in 90..100 -> {
               println("戒骄戒躁")
               "优秀"
           }
           in 80..89 -> "良好"
           in 70..79 -> "中"
           in 60..69 -> "及格"
           else -> {
               println("再接再厉")
               "不及格"
           }
       }
       println(str)
   }
   

6. when分支处理类型

   使用is、!is运算符，处理类型。

   fun main(args: Array<String>) {
       val inputPrice = 26
       println(realPrice(inputPrice))
   }
   
   fun realPrice(inputPrice: Any) = when (inputPrice) {
       is String -> inputPrice.toDouble()
       is Int -> inputPrice.toDouble()
       is Double -> inputPrice
       else -> 0.0
   }
   

7. when条件分支

   可以用来取代if...else if链，此时不需要为when分支提供任何表达式，每个分支条件都是一个布尔表达式，例如上面if表达式使用when条件分支代替。

   fun main(args: Array<String>) {
   
       val age = 18
       // when分支不需要任何条件表达式
       val str = when {
           // 每个分支条件都是布尔表达式
           age > 20 -> {
               println("大于20的分支")
               "age大于20"
           }
           age < 20 -> {
               println("小于20的分支")
               "age小于20"
           }
           else -> {
               println("等于20的分支")
               "age等于20"
           }
       }
       println(str)
   }
   

   再来一个，没有返回值的例子。

   fun main(args: Array<String>) {
       // 读取一行输入，返回是String?类型，需要判断才能使用
       /*val ln = readLine()
       if (ln == null) {
           return
       }*/
       // 上面三行可以使用Elvis简化为一行
       val ln = readLine() ?: return
       when {
           ln.matches(Regex("\\d+")) -> println("输入的全是数字")
           ln.matches(Regex("[a-zA-Z+]")) -> println("输入的全是字母")
           ln.matches(Regex("[a-zA-Z0-9]+")) -> println("输入的是字母和数字")
           else -> println("输入包含特殊字符")
       }
   }
   

2. 循环结构

1. while循环

   与Java一致。注意如果while循环后面有一个分号（分号相当于一条空语句），此时while循环将只控制这条空语句作为循环。

2. do while循环

   与Java一致。

3. for-in循环

   用于遍历范围、序列、集合、数组中的元素。

   fun main(args: Array<String>) {
   
       for (num in 1..5 step 2) {
           print("$num ") // 输出1 3 5
       }
   }
   

   for-in循环可以遍历任何可迭代对象。所谓可迭代对象就是该对象包含一个interator()的方法，且该方法的返回值对象具有next()、hasNext()方法，这三个方法都使用operator修饰。

4. 嵌套循环

   与Java一致。

3. 控制循环结构

1. break结束循环

   与Java一致。

   使用@标识符，可以结束外层循环。

   fun main(args: Array<String>) {
   
       outer@ for (i in 0 until 5) {
           for (j in 0 until 3) {
               println("i的值为：$i，j的值为：$j")
               if (j == 1) {
                   break@outer
               }
           }
       }
   }
   

   打印结果

   i的值为：0，j的值为：0
   i的值为：0，j的值为：1
   

2. continue忽略本次，循环剩下的语句

   与Java一致。

   使用@标识符，可以忽略外层本次，循环外层剩下的语句。

   fun main(args: Array<String>) {
   
       outer@ for (i in 0 until 2) {
           for (j in 0 until 3) {
               println("i的值为：$i，j的值为：$j")
               if (j == 1) {
                   continue@outer
               }
           }
       }
   }
   

   打印结果

   i的值为：0，j的值为：0
   i的值为：0，j的值为：1
   i的值为：1，j的值为：0
   i的值为：1，j的值为：1
   

3. return结束方法

   与Java一致。

重点

• if表达式
• when语句和表达式