Kotlin编程之Break标签和Return标签及Continue标签

Kotlin编程相关知识点介绍：

• Kotlin编程之使用Intellij IED和了解源文件（.kt）
• Kotlin编程之类的介绍和使用
• Kotlin编程之类的属性
• Kotlin编程之方法
• Kotlin编程之父类和继承父类
• Kotlin编程之接口和实现接口
• Kotlin编程之伴生对象，抽象类，密封类
• Kotlin编程之嵌套类，内部类，匿名内部类
• Kotlin编程之对象的表达式和声明
• Kotlin编程之扩展方法
• Kotlin编程之扩展属性和扩展伴生对象
• Kotlin编程之泛型
• Kotlin编程之if语句，while循环，when表达式，for循环
• Kotlin编程之可见性修饰词（private,protected,internal,public）
• Kotlin编程之代理模式
• Kotlin编程之高阶函数，Lambda表达式，匿名函数

---

Kotlin编程中以后三种转跳操作符：

• return：结束最近的闭合循环

• break：结束最近的闭合循环

• continue:跳到最近的闭合循环的下一次循环

Break和Continue标签

---

案例1：在单个for循环中使用breadk和continue标签

编写如下代码：

package com.xingen.kotlin.day201761

fun main(args: Array<String>) {
    test1()
}
fun  test1(){
    for (j in 0..10){
            if (j==5){
                println("当前值为 $j， 使用break标签 跳出循环")
                break
            }else{
                println("当前值为 $j，使用continue标签继续下一次循环")
                continue
            }
    }
}

输出结果：

当前值为 0，使用continue标签继续下一次循环
当前值为 1，使用continue标签继续下一次循环
当前值为 2，使用continue标签继续下一次循环
当前值为 3，使用continue标签继续下一次循环
当前值为 4，使用continue标签继续下一次循环
当前值为 5， 使用break标签 跳出循环

案例2： 嵌套for循环，指定跳转到最外层的for循环

编写代码如下：

package com.xingen.kotlin.day201761

fun main(args: Array<String>) {
    test2()
}

/**
 *  嵌套for循环，指定跳转到最外层的for循环：
 *
 *  1. 自定义一个标签,xxx@
 *
 *  2. 在最外层的for循环中添加自定义的标签， 使用break@xxx或者continue@xxx，来转跳
 */
fun test2() {
    loop@ for (j in 0..10) {
        for (i in j..10) {
            if (i==5&&j == 5) {
                println("当外层值为 $j 内层值为$i， 使用break标签 跳出循环")
                break@loop
            } else {
                println("当外层值为 $j 内层值为$i，使用continue标签继续下一次循环")
                continue@loop
            }
        }
    }
}

输出结果:

当外层值为 0 内层值为0，使用continue标签继续下一次循环
当外层值为 1 内层值为1，使用continue标签继续下一次循环
当外层值为 2 内层值为2，使用continue标签继续下一次循环
当外层值为 3 内层值为3，使用continue标签继续下一次循环
当外层值为 4 内层值为4，使用continue标签继续下一次循环
当外层值为 5 内层值为5， 使用break标签 跳出循环

Return标签

---

Return返回最外层函数：

一个不带标签的 return 语句 总是在用 fun 关键字声明的函数中返回。
这意味着 lambda 表达式中的 return 将从包含它的函数返回.

package com.xingen.kotlin.day201761

fun main(args: Array<String>) {

    test2 { change() }
}
/**
 * 高阶函数，接受一个函数作为参数
 */
fun test2(changeFun:()->Unit){
    changeFun()
    println("高级函数的Lambda表达式执行完")
}

var  list= listOf<Int>(1,2,3)
/**
 *  传入作为的参数的函数
 */
fun change(){
    /**
     * Lambda表达式，单个参数，时候可以省略声明参数和->
     *
     *  即以下代码等于：
     *      list.forEach {
     *          if (item==2) return
     *          println("当前遍历的值是 $item")
     *      }
     */

    list.forEach {
         item->
          if (item==2) return
          println("当前遍历的值是 $item")
    }
    println("list集合遍历完成")
}

输出结果如下：

当前遍历的值是 1
高级函数的Lambda表达式执行完

输出结果发觉，return返回的是在test2函数中，也就是包含Lambda表达式作为参数的函数中。

Return返回最近的闭合函数：

若是希望return返回到最近的闭合函数，即在change（）中，而不是test2()，可以使用标签。该标签可以是传入的
lambda 表达式名字相同的标签

fun change(){
    list.forEach  {
         item->
          if (item==2) return@forEach //使用标签
          println("当前遍历的值是 $item")
    }
    println("list集合遍历完成")
}

输出结果如下：

当前遍历的值是 1
当前遍历的值是 3
list集合遍历完成
高级函数的Lambda表达式执行完