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

迷南。 2022-06-15 12:50 250阅读 0赞

**Kotlin编程相关知识点介绍**：

*  [Kotlin编程之使用Intellij IED和了解源文件（.kt）][Kotlin_Intellij IED_.kt]
 *  [Kotlin编程之类的介绍和使用][Kotlin]
 *  [Kotlin编程之类的属性][Kotlin 1]
 *  [Kotlin编程之方法][Kotlin 2]
 *  [Kotlin编程之父类和继承父类][Kotlin 3]
 *  [ Kotlin编程之接口和实现接口][Kotlin 4]
 *  [Kotlin编程之伴生对象，抽象类，密封类][Kotlin 5]
 *  [Kotlin编程之嵌套类，内部类，匿名内部类][Kotlin 6]
 *  [Kotlin编程之对象的表达式和声明][Kotlin 7]
 *  [Kotlin编程之扩展方法][Kotlin 8]
 *  [ Kotlin编程之扩展属性和扩展伴生对象][Kotlin 9]
 *  [ Kotlin编程之泛型][Kotlin 10]
 *  [Kotlin编程之if语句，while循环，when表达式，for循环][Kotlin_if_while_when_for]
 *  [Kotlin编程之可见性修饰词（private,protected,internal,public）][Kotlin_private_protected_internal_public]
 *  [Kotlin编程之代理模式][Kotlin 11]
 *  [Kotlin编程之高阶函数，Lambda表达式，匿名函数][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表达式执行完

[Kotlin_Intellij IED_.kt]: http://blog.csdn.net/hexingen/article/details/72820445
[Kotlin]: http://blog.csdn.net/hexingen/article/details/72820822
[Kotlin 1]: http://blog.csdn.net/hexingen/article/details/72820984
[Kotlin 2]: http://blog.csdn.net/hexingen/article/details/72821113
[Kotlin 3]: http://blog.csdn.net/hexingen/article/details/72822247
[Kotlin 4]: http://blog.csdn.net/hexingen/article/details/72822291
[Kotlin 5]: http://blog.csdn.net/hexingen/article/details/72823961
[Kotlin 6]: http://blog.csdn.net/hexingen/article/details/72824084
[Kotlin 7]: http://blog.csdn.net/hexingen/article/details/72824164
[Kotlin 8]: http://blog.csdn.net/hexingen/article/details/72824443
[Kotlin 9]: http://blog.csdn.net/hexingen/article/details/72824488
[Kotlin 10]: http://blog.csdn.net/hexingen/article/details/72824527
[Kotlin_if_while_when_for]: http://blog.csdn.net/hexingen/article/details/72824571
[Kotlin_private_protected_internal_public]: http://blog.csdn.net/hexingen/article/details/72824614
[Kotlin 11]: http://blog.csdn.net/hexingen/article/details/72824641
[Kotlin_Lambda]: http://blog.csdn.net/hexingen/article/details/72853868