Kotlin——流程控制

2021-04-26 本文已影响0人 So_ProbuING

与Java类似，Kotlin同样提供了两种基本的流程控制结构：分支结构和循环结构

顺序结构

在任何编程语言中最常见的程序结构就是顺序结构，顺序结构就是程序从上到下一行行地执行，中间没有任何判断和跳转

分支结构

if分支

Kotlin的if分支既可作为语句使用，也可作为表达式使用
Kotlin的if语句有如下三种形式：

if(expression){
  statements...
}

if else

if(expression){
  statements...
}else{
  statements...
}

if else if

if(expression){
  statements...
}
else if(expression){
  statements...
}
...
else{
  statements
}

如果if、else if、else后的代码块只有一行语句，则可以省略花括号。

 var age = 20
    if (age>=30){
        println("大于等于30")
    }else{
        println("不大于30")
    }

if表达式

Kotlin的if分支还可作为表达式使用，整个if表达式(包括else)最终会返回一个值，因此if可以代替java中的三目运算符

 var age = 20
    var str = if(age>20) "age大于20" else if(age<20) "age小于20" else "age等于20"
    println("str的值为${str}")

当使用if分支作为表达式时，由于if表达式必须要有返回值，因此if表达式需要有else部分

when分支语句

when分支取代了Java原有的switch语句

 var score = 'B'

    when(score){
        'A' -> print("优秀")
        'B' -> print("优秀")
        'C' -> print("良好")
        else -> print("不及格")
    }

从上面的程序不难发现 when分支其实就是switch分支的简化，when分支的改变有以下几点：

不再使用case关键字
case值后的冒号改为使用箭头(->)
default 改为else

when分支如果包含多条语句，则需要使用花括号将这些语句括成一个整体形成代码块

when分支比Switch分支强大的地方

when 分支可以匹配多个值
when分支后的值不要求是常量，可以是任意表达式
when分支对条件表达式的类型没有任何要求

var score = 'D'

    when(score){
        'A','B' ->{
            println("A、B取值范围内")
        }
        'C','D' ->{
            println("C、D取值范围内")
        }
        
    }

when表达式

与if分支相同，when分支也可作为表达式
如果when分支被当做表达式，那么符合条件的分支的代码块的值就是整个表达式的值
当when语句作为表达式使用时，when表达式也需要有一个返回值，因此when表达式通常必须有else分支

  //when表达式
    var score = 'A'

    var str = when(score){
        'A' -> "A"
        'B' -> "B"
        else -> "unKnow"
    }

    println(str)

when分支处理范围

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

 var randomInt = Random().nextInt(100)
    print("随机数取值${randomInt}")
    when (randomInt) {
        in 10..25 -> print("在10-25")
        in 26..50 -> print("在26-50")
        in 51..80 -> print("在51-80")
        else -> print("其他")
    }

when分支处理类型

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

  var inputArr = 26
    when(inputArr){
        is String -> print("是字符串String")
        is Int -> print("是int")
        is Double -> println("是double")
        else -> 0.0
    }

when条件分支

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

  var rl = readLine()
    if (rl != null) {

        when {
            rl.matches(Regex("\\d+")) -> {
                print("您输入的都是数字")
            }

            rl.matches(Regex("[a-zA-Z]+")) -> {
                print("您输入的是字母")
            }
            rl.matches(Regex("[a-z0-9A-Z]+")) -> {
                println("您输入的是字母和数字")
            }
            else -> {
                println("您输入的是特殊符号")
            }
        }
    }

当when用作条件分支时，不需要任何条件表达式，每个分支都是一个布尔表达式

循环结构

循环语句可以在满足循环的情况下，反复执行某一段代码。循环语句可能包含如下4个部分。

初始化语句：一条或多条语句，用于完成一些初始化工作，初始化语句在循环开始之前执行
循环条件：这是一个布尔表达式，这个表达式能决定是否执行循环体
循环体：这个部分是循环的主体，如果循环条件允许，这个代码块将被重复执行。如果这个代码块只有一行语句，则这个代码块的花括号是可以省略的
迭代语句这个部分在一次循环体执行结束后，对循环条件求值之前执行。通常用于控制循环条件中的变量

while循环

语法

[init_statement]
while(test_expression){
  body_statement
  {iteration_statements}
}

while循环在每次执行循环体之前，都要先对test_expression循环条件求值，如果循环条件为真，则运行循环体部分。

fun whileCirculation() {
    var count = 0
    while (count<50){
        print("count${count}")
        count++
    }
    println("循环结束")
}

使用while循环时要保证有结束循环条件避免死循环
如果while循环的循环体只有一行语句，那么Kotlin允许省略循环体的花括号

do while循环

do while循环与while循环的区别在于：while循环是先判断循环条件，如果条件为真则执行循环体；do while循环则先执行循环体，然后才判断循环条件

语法

[init_statement]
do{
  body_statement
  [iteration_statement]
}while(test_expression)

fun doWhileCirculation() {
    var count = 0;
    do {
        count++
        print("count${count}")
    } while (count < 30)
    println("循环结束")
}

即使test_expression循环条件的值一开始就是假，do while循环也会执行循环体，也就是说do while循环的循环体至少执行一次

for-in 循环

for-in 循环专门用于遍历范围、序列和集合等包含的元素

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

for-in 循环中的常量无须声明。for-in循环中的常量将会在每次循环开始时自动被赋值
for-in循环可用于遍历任何可迭代对象，可迭代对象就是该对象包含一个iterator()方法，且该方法的返回值对象具有next()、hasNext()方法

fun forCirculation() {
    var max = 7
    var result =1
    for (num in 1..max){
        result*=num
    }
    println(result)
}

for-in循环的循环计数器相当于用val声明的常量，因此不允许被重新赋值

嵌套循环

如果把一个循环放在另一个循环体内，那么就形成了嵌套循环，嵌套循环既可以是for-in循环嵌套while循环也可以是while循环嵌套do while循环

 var i = 10
    var j = 10
    for (iv in 0..i){
        for (jv in 0..j) {
            println("i ${iv} j ${jv}")
        }
    }

控制循环结构

break

break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦循环体重遇到break，系统将完全结束循环并开始执行循环之后的代码

fun breakFinish() {
    val i = 100
    for (a in 1..i) {
        if (a > 50) {
            println("循环结束${a}")
            break
        }
    }
    println("after continue")
}

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

 //结束外层循环
    a@for(a in 0 until 10){
        for (b in 2 until 30){
            println("a ${a} b ${b}")
            if (b == 15) {
                break@a
            }
        }
    }

break后的标签必须使一个有效的标签，即这个标签必须在break语句所在的循环之前定义

continue

continue可以忽略本次循环剩下的语句，接着开始下一次循环，并不会结束循环

 for (i in 1..10) {
        print("i ${i}")
        if (i ==5) {
            continue
        }
    }

与break类似，continue后也可以紧跟一个标签，用于直接跳过标签所标识循环的当次循环的剩下语句

return

return用户从函数或者匿名函数中返回。当程序执行遇到return时，这个函数或方法将被结束

      returnFinish()
    println("主程序继续执行")
}

fun returnFinish() {
    for (i in 1 until 100){
        print("i的值${i}")
        if (i == 99) {
            return
        }
    }
}