Kotlin基础-for循环return、break、continue

一、前言：

java中return、break、continue的含义：

• 1、break：不仅可以结束其所在的循环，还可结束其外层循环，但一次只能结束一种循环。
• 2、continue：结束的是本次循环，将接着开始下一次循环。
• 3、return：同时结束其所在的循环和其外层循环。

二、Kotlin中的使用：

1、与Java的相同点

以下Kotlin代码跟Java，使用return、break、continue关键字效果一致。

• index==3 return，结束该次循环，跳出循环体，forTest方法返回，不会打印“03”；
• index==3 break，结束该次循环，跳出循环体，会打印“03”；
• index==3 continue，结束该次循环，执行下一次循环，最后会打印“03”；
  for(xxx in xxx){}，这种方式使用return、break、continue跟Java一致；

 private fun forTest1() {
        val list = listOf(1, 2, 3, 4, 5, 6, 7)
        for (index in 0 until list.size) {
            if (index == 3){
                Log.d("LUO", "01**********")
                // return//相当于Java的return 结果：01执行,02执行
                // break///相当于Java的break 结果：01执行,02执行,03执行,结束循环
                 continue//相当于Java的continue 结果：01执行,02执行,03执行
            }
            Log.d("LUO", "02**********")
        }
        Log.d("LUO", "03**********")
    }

2、与Java的不同点 – 自定义标签

• looper@是自定义标签，用于标记某个位置，格式：xxx@；
• break@looper，相当于Java的break；
• continue@looper，相当于Java的continue；
• return@looper，这是不合法的；

  private fun forTest2() {
        val list = listOf(1, 2, 3, 4, 5, 6, 7)
        looper@ for (index in 0 until list.size) {
            if (index == 3){
                Log.d("LUO", "01**********")
                //break@looper//相当于Java的break 结果：01执行,02执行，03执行
                continue@looper//相当于Java的continue 结果：01执行,02执行,03执行
                //return@looper//这是不合法的
            }
            Log.d("LUO", "02**********")
        }
        Log.d("LUO", "03**********")
    }

3、forEach遍历1

forEach，用迭代器遍历集合；

• return@forEach，相当于Java的 continue；
• return，相当于Java 的return；
• continue，在这里是不合法的；
• break ，在这里是不合法的；

 private fun forTest3() {
        val list = listOf(1, 2, 3, 4, 5, 6, 7)
        list.forEachIndexed{ index,value->
            if (value == 3){
                Log.d("LUO", "01***********index:${index}")
               return@forEachIndexed //相当于Java的 continue结果：01执行,02执行，03执行
               // return //相当于Java 的return 结果：01执行,02执行
               // break //不支持
               // continue //不支持
            }
            Log.d("LUO", "02**********index:${index}")
        }
        Log.d("LUO", "03**********")
    }

4、forEach遍历2

   private fun forTest4() {
        val list = listOf(1, 2, 3, 4, 5, 6, 7)
        run forEach@{
            list.forEachIndexed{ index,value->
                if (value == 3){
                    Log.d("LUO", "01***********index:${index}")
                    //return //相当于Java 的return 结果：01执行,02执行
                    //return@forEachIndexed //相当于Java的 continue结果：01执行,02执行，03执行
                    return@forEach //相当于Java的break 结果：01执行,02执行,03执行
                    //break@forEach //不支持
                    //continue@forEach //不支持
                }
                Log.d("LUO", "02**********index:${index}")
            }

        }
        Log.d("LUO", "03**********")
    }

三、KotlinforEach使用continue,和break都会报错

错误：The label '@forEach' does not denote a loop
这个是在kotlin中遍历集合时，使用标签的过程中，可能会遇到的小错误。

提示的字面上的信息，就是在forEach中这个标签不能表示为loop(也就是循环)，错误事例如下：

    val list = listOf(1, 2, 3, 4, 5, 6, 7)
list.forEach loop@{
      if (it ==3) {
           continue @loop
       }
   }

这里使用continue,和break都会报错。使用return就会正常了，让我们看看源码：

/**
 * Performs the given [action] on each element.
 */
@kotlin.internal.HidesMembers
public inline fun  Iterable.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

很明显forEach是一个fun，并不是一个loop

那么相对应的，在for 循环中使用return 也同样会报错。
错误代码如下：

loop@ for (i in 0..4)  
               for (j in 5..9) {
                   if (j == 8) {
                       return@loop
                  }
           }

这个时候编译器会给一个warn:Target label does not denote a function

改正：我们可以使用continue，或者break,看你的实际情况来定。

官方讲解:

Returns and Jumps(返回和跳转)
Kotlin has three structural jump expressions(Kotlin有三个结构跳跃表达式):

• return. By default returns from the nearest enclosing function or anonymous function.(默认情况下，从最近的封闭函数或匿名函数返回)
• break. Terminates the nearest enclosing loop.(终止最近的封闭循环)
• continue. Proceeds to the next step of the nearest enclosing loop.(继续执行最近的封闭循环的下一步)