Kotlin学习之流程控制

你的名字 2024-02-18 18:38 39阅读 0赞

## Kotlin学习之流程控制 ##

@(Kotlin学习)

Kotlin的流程控制，可以分为**条件语句**和**循环语句**。

### 一、条件语句 ###

##### 1.1if-else条件判断语句 #####

Kotlin中的if条件语句与其他类C语言相比，最大的区别在于**if语句本身就是个有返回值的表达式**。所以也就不需要三元运算符（条件?然后:否则），因为**if**就能胜任。

下面用一个函数做一下对比：

// Java 语言写法
    public static int max(int a, int b) {
        if (a <= b)
            return b;
        else
            return a;
        // 或者使用三目运算符 return (a <= b)?b:a;
    }
    
    //Kotlin的简洁写法
    fun max(a:Int,b:Int)=if (a<=b) b else a
    
    //Kotlin的传统写法
    fun max(a: Int, b: Int) {
        if (a <= b) 
            return b 
        else 
            return a
    }

注意：  
\- **如果要把if语句当作表达式使用，那么一定要有else部分，否则就会出现编译错误。**；

##### 1.2when条件选择语句 #####

Kotlin使用when语句代替类C语言中的switch语句，但是它要比switch更加强大。

其最简单的形式如下：

val x=3
        when(x){
            1-> print("x==1")
            2-> print("x==2")
            else->{
                print("x is neither 1 nor 2")
            }
        }

*  **when**将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。
 *  **when**既可以被当做表达式使用也可以被当做语句使用；
 *  如果when被当做表达式，符合条件的分支的值就是整个表达式的值；如果当做语句使用，则忽略个别分支的值。
 *  如果其他分支都不满足条件将会求值else分支。
 *  如果when作为一个表达式使用，则必须有else分支，除非编译器能够检测出所有的可能情况都已经覆盖了。

如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

val x=2
        when(x){
            1,2-> print("x==$x")
            else->{
                print("x is neither 1 nor 2")
            }
        }

也可以用任意表达式（不只是常量）作为分支条件:

when (x) {
        parseInt(s) -> print("s encodes x")
        else -> print("s does not encode x")
    }

可以在判断条件里用两种高级的表达式：  
\- is和!is：判断值是否是某个类的实例；  
\- in和!in：判断值是否在某个区间、数组或集合内；

when (x) {
        !is Int -> println("x is not integer")
        in 0..10 -> println("x is between 0 and 10")
        else -> println("x is over 10")
    }

when也可以用来取代if-else if链。如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

when {
        x.isOdd() -> print("x is odd")
        x.isEven() -> print("x is even")
        else -> print("x is funny")
    }

与if语句用作表达式时要求一致，when语句用作表达式时必须有else部分，否则会出现编译错误。

### 二、循环语句 ###

Kotlin中的循环语句有for和while两个。

##### 2.1for循环语句 #####

Kotlin中的for循环抛弃了类C语言中的三段式参数，类C语言的方式存在如下弊端：  
1. 非常容易在边界问题上出错；  
2. 为指定循环次数引入不必要的参数；  
3. 写法臃肿。

Kotlin为了解决这个问题，对for循环进行了改革：  
\- Kotlin规定所有的for循环都使用**遍历元素 in 遍历对象**确定遍历的方式，  
\- “遍历对象”可以是区间、数组、集合和其他任何提供了iterator迭代器的对象。

直接使用for循环遍历**数组和集合**中的元素：

val ints = intArrayOf(1, 2, 3, 4, 5)
        for (item in ints) {
            println("$item")
        }

如果需要遍历数组或集合的索引，可以使用数组和集合的**indices**属性：

val ints = intArrayOf(1, 2, 3, 4, 5)
    for (i in ints.indices) {
        println("inits[$i] == ${ints[i]}")
    }

如果需要遍历数组和集合的索引和值，可以使用库函数里的withIndex()方法，此方法返回一个IndexedValue对象，通过**解构声明**可以同时获取索引和值：

val ints = intArrayOf(1, 2, 3, 4, 5)
    for ((index, value) in ints.withIndex()) {
        println("inits[$index] == $value")
    }

只要是实现了Compare接口的类型，都能使用区间，但是我们一般用的比较多的是**整数区间**，而且**只有整数区间才能用作for循环中的迭代**：

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

如果想**倒序循环**，可以使用**downTo()**函数，一般写成中缀的形式：

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

如果指定**步长**可以使用**step()**函数，一般写成中缀的形式（步长只能是**整数**）：

for (i in 5 downTo 1 step 3) println(i) //输出 5 2
    
    for (i in 1..5 step 2) println(i) //输出 1 3 5

##### 2.2While循环 #####

while和do…while照常使用，与Java用法相同。

while (x > 0) {
        x--
    }
    
    do {
      val y = retrieveData()
    } while (y != null) // y 在此处可见

### 三、返回和跳转 ###

Kotlin中也有三个用来跳转的关键字：  
\- **return**：默认从最直接包围它的函数或者匿名函数返回；  
\- **break**：终止最直接包围它的循环；  
\- **continue**：继续下一次最直接包围它的循环。

##### 3.1Break与Continue标签 #####

在Kotlin中任何表达式都可以用标签（label）来标记。

标签的格式为标识符后跟`@`符号：

标签名 @ 表达式

可以使用标签来限制break或者continue，在循环中使用标签可以指定跳转的位置：

fun main(args: Array<String>) {
        loop@for (i in 1..5) {
            println("i==$i")
            for (j in 1..5) {
                println("j==$j")
                if (j == 3) {
                    break@loop//终止最外层循环
                }
            }
        }
    }

输出结果为：

i==1
    j==1
    j==2
    j==3

如果不适用loop标签，break将会终止j的循环：

fun main(args: Array<String>) {
        for (i in 1..5) {
            println("i==$i")
            for (j in 1..5) {
                println("j==$j")
                if (j == 3) {
                    break
                }
            }
        }
    }

输出结果为：

i==1
    j==1
    j==2
    j==3
    i==2
    j==1
    j==2
    j==3
    i==3
    j==1
    j==2
    j==3
    i==4
    j==1
    j==2
    j==3
    i==5
    j==1
    j==2
    j==3

*  标签限制的**break**跳转到刚好位于标签指定的循环后面的执行点；
 *  \*\*continu\*\*e继续标签指定的循环的下一次迭代。

##### 3.2标签处返回 #####

Kotlin标签的强大之处在于它可以控制return的返回对象。Kotlin有函数字面量、局部函数和对象表达式。

标签限制的return允许我们从外层函数返回。最重要的一个用途就是从lambda表达式中返回：

fun main(args: Array<String>) {
        val ints = intArrayOf(1, 2, 3)
        ints.forEach {
            if (it == 2) return
            println(it)//输出结果为1
        }
    }

上面的**forEach()**函数，它是——Arrays.kt文件中定义的扩展函数，所有数组都扩展了这个函数。上例中使用**forEaxh()**函数遍历ints数组中的元素，对于每个元素，我们检查它是否等于2.等于2就跳过，不等于2就打印出来。

但是return只会跳出一个显式定义的函数，不会跳出lambda表达式；如果想要跳出lambda表达式，可以使用标签标记lambda表达式，然后让return返回到标签处：

fun main(args: Array<String>) {
        val ints = intArrayOf(1, 2, 3)
        ints.forEach eac@{
            if (it == 2) return@eac
            println(it)//输出1,3,
        }
    }

为了简化程序，Kotlin给每个高阶函数添加了一个隐式标签，标签与函数同名，所以上面的例子可以写成：

fun main(args: Array<String>) {
        val ints = intArrayOf(1, 2, 3)
        ints.forEach {
            if (it == 2) return@forEach
            println(it)
        }
    }

如果return后有返回值，再加标签就要写成**return@标签 返回值**的形式：

return@sec  1 // 返回值 1 到 loop 标记的函数处

### 学海无涯苦作舟 ###

**朋友们可以关注我的微信公众号，一起进步！！！**  
![这里写图片描述][Image 1]

[Image 1]: