Kotlin - 控制语句 for、 while

 for

任何提供了迭代器的对象都可以被循环遍历。有一下三种类型：

iterator 迭代器	for ( item in items ) { print( item ) }
index 索引遍历	for ( i in array.indices ) { print( arr[i] ) }
withIndex 库函数	for ( (index,value) in array.withIndex() ) { print( "$index,$value" ) }

val num = arrayOf(1, 2, 3)
for(i in num) print("$i,")    //打印：1,2,3,
num.forEach{ e -> print("$i,") }    //打印：1,2,3,
 
for(i in 4 downTo 1) print(i)    //打印：54321
 
//多层嵌套循环的终止结合标签用法
for(x in 1..5){
//    printlin("外循环第$x次打印")
    for(y in 1..5){
//        if(i ==5) break        //跳出整个内循环，继续外循环
//        if(i ==5) continue     //跳出本次内循环，继续下次内循环
//        if(i ==5) return       //直接跳出所有循环
//        println("内循环第$y次打印")
    }
}

while

while(num > 0){
    ...
}

//先执行再循环（不管怎样都会至少执行一次）
do{
    ...
}while(num > 0){
    ...
}

循环控制

continue	跳过当前循环，继续下次循环
break	终止当前循环，存在嵌套循环就继续外循环
return	终止当前函数运行，存在嵌套函数就继续外部函数
label	任何表达式都可以用标签来标记 添加标签使用 ***@，调用便签使用 @***，会返回到标签处

val args = intArrayOf(1, 2, 3, 4, 5)

for (arg in args) {
    if (arg == 2) continue    //跳过本次循环，继续下次循环
    if (arg == 4) break       //直接终该循环（存在嵌套循环就执行外循环）
    print("$arg ") // 1 3
}

Outter@ for (arg in args) {
    println("outter: $arg")
    var i = arg
    print("inner: ")
    Inner@ while (i > 0) {
        if (arg == 2) break@Inner // 当外循环元素为2时，跳过while，进行下次for
        if (arg == 4) break@Outter // 当外循环元素为3时，直接跳出for
        print("$i ")
        i--
    }
    println()
}

Kotlin 有函数字面量(函数表达式)、局部函数、对象表达式(匿名内部类)，因此函数可以被嵌套。return 会直接结束掉最直接包裹它的 fun函数，使用标签限制的return，可以从局部结束返回到外层调用者，而不是结束掉整个，例如从Lambada表达式中返回。

类似于 continue 效果： 从局部 return

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return //直接结束fun包裹的范围，返回到foo()的调用者，也就是整个函数结束
        print(it)
    }
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach aaa@{
        if (it == 3) return@aaa //返回到Lambda表达式的调用者, 即forEach，打印1245
        print(it)
    }
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach //同上简写，使用了隐含标签，与Lambada表达式同名
        print(it)
    }
}

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
        if (value == 3) return  //结束当前fun包裹的匿名函数，返回到外层调用者，即forEach，打印1245
        print(value)
    })
}

类似于 break 效果：从 Lambda表达式 return

fun foo() {
    run bbb@{
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@bbb //从传入的Lambda表达式返回，返回外层调用者即run，打印12
            print(it)
        }
        print(" foreach")
    }
    println("run")
}