Kotlin 循环控制

前面其实我们在一些Demo中已经接触到了循环的一些用法。

For 循环

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，如：

for (item: Int in ints) {
    // ……
}

或：

for (item in collection) print(item)

也可以遍历集合的下标

   fun forMethod(args: ArrayList<String>){
         
         for (i in args.indices){
             print(i)
         }
   }

还可以写成这样：

for ((key,value) in args.withIndex()){
     print("the element at $key is $value")
 }

while 与 do...while 循环

while循环与在Java中的语法几乎没啥区别：

while( 布尔表达式 ) {
  //循环内容
}

do...while 也一样，对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

do {
       //代码语句
}while(布尔表达式);

实例

fun main(args: Array<String>) {
    println("----while 使用-----")
    var x = 5
    while (x > 0) {
        println( x--)
    }
    println("----do...while 使用-----")
    var y = 5
    do {
        println(y--)
    } while(y>0)
}

返回和跳转

Kotlin 有三种结构化跳转表达式：

return。默认从最直接包围它的函数或者匿名函数返回。
break。终止最直接包围它的循环。
continue。继续下一次最直接包围它的循环。

Break 和 Continue 标签

在 Kotlin 中任何表达式都可以用标签（label）来标记。标签的格式为标识符后跟@ 符号，例如：abc@、fooBar@都是有效的标签。要为一个表达式加标签，我们只要在其前加标签即可。

loop@ for (i in 1..100) {
    // ……
}

现在，我们可以用标签限制 break 或者continue：

loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop
    }
}

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

下面是一个实例，可以帮助你更好的理角label在循环中的应用

fun labelTest() {
        loop@ for (i in 1..5) {
            Log.e("LabelTest","print i = $i before")
            for (j in 1..5) {
                if (j % i != 0) {
                    Log.e("LabelTest"," break to loop at i =$i, j =$j")
                    break@loop
                }
                if (j % 2 == 0) {
                    Log.e("LabelTest"," continue to loop at i =$i, j =$j")
                    continue@loop
                }
                Log.e("LabelTest"," run at i = $i,j=$j")
            }
            Log.e("LabelTest","print i = $i after")
        }
}

将外层循环命名为loop之后，内层循环出现j不能整除i的情况，就在loop指定的循环中跳出。
相当于在外层循环调用break.而下面的j为偶数时，则相当于在外层循环中调用continue.下面是输出结果：

print i = 1 before
run at i = 1,j=1
continue to loop at i =1, j =2
print i = 2 before
break to loop at i =2, j =1

标签处返回

Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。标签限制的 return 允许我们从外层函数返回。最重要的一个用途就是从 lambda 表达式中返回。

fun labelReturn() {
        val array = Array(5, { index -> index + 1 })

        array.forEach  {

            if(it==4){
                return
            }

            Log.e(TAG, " index = $it")

        }

        Log.e(TAG, "print after foreach")

}

这个 return 表达式从最直接包围它的函数即 labelReturn 中返回。输出结果为:

index = 1
index = 2
index = 3

如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。
修改成如下：

fun labelReturn() {
        val array = Array(5, { index -> index + 1 })

        array.forEach loop@  {
            if(it==4){
                return@loop
            }
            Log.e(TAG, " index = $it")
        }
        Log.e(TAG, "print after foreach")
}

输出结果如下：

index = 1
index = 2
index = 3
index = 5
print after foreach

不难看出当下标为4时，将loop标记的整个代码块作为了返回值从lambda表达式中返回。但并没有终止整个labelReturn函数。

通常情况下使用隐式标签更方便。该标签与接受该 lambda 的函数同名，所以上面的代码可以改写为：

fun labelReturn() {
        val array = Array(5, { index -> index + 1 })

        array.forEach   {
            if(it==4){
                return@forEach
            }
            Log.e(TAG, " index = $it")
        }
        Log.e(TAG, "print after foreach")
    }

输出结果完全相同。

当要返一个回值的时候，解析器优先选用标签限制的 return，即

return@block 1

意为"从标签 @block 返回 1"，而不是"返回一个标签标注的表达式 (@block 1)"。