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跳转到刚好位于标签指定的循环后面的执行点；
• continue继续标签指定的循环的下一次迭代。

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 标记的函数处

学海无涯苦作舟

我的微信公众号.jpg