Kotlin学习笔记（三）【循环控制】

for循环

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

fun main(args: Array<String>) { 
    val arrays = intArrayOf(1,2,3,4,5)
    for (item in arrays) println(item)
}

循环体可以是一个代码块:

fun main(args: Array<String>) { 
    val arrays = arrayOf(1,2,3,4,5)
    for (item: Int in arrays) println(item)
}

如上所述，for 可以循环遍历任何提供了迭代器的对象。
如果想要通过索引遍历一个数组或者一个 list，可以这么做：
indices

fun main(args: Array<String>) { 
    val arrays = arrayOf(1,2,3,4,5)
    for (i in arrays.indices) {
      println(arrays[i])  
    } 
}

注意这种”在区间上遍历”会编译成优化的实现而不会创建额外对象。
或者你可以用库函数 withIndex：

fun main(args: Array<String>) { 
    val arrays = arrayOf(1,2,3,4,5)
    for ((index,value) in arrays.withIndex()) {
      println("index is $index value is $value")  
    } 
}

while与do…while循环

while是最基本的循环：

fun main(args: Array<String>) {
    var maxCount = 3
    while (maxCount > 0) {
        println(maxCount --) // 3, 2, 1      
    }
}

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

fun main(args: Array<String>) {
    var maxCount = 3
    do {
        println(maxCount --) //3
    } while(maxCount > 3)   
}

返回和跳转

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

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

在循环中 Kotlin 支持传统的 break 和 continue 操作符。

fun main(args: Array<String>) {
    for (i in 0..10) {
        if (i == 3) continue       
        if (i == 6) break
        println(i) // 0, 1, 2, 4, 5
    }
}

Break 和 Continue 标签

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

fun main(args: Array<String>) {
    qfxl@ for (i in 1..3) {
        for (j in 1..2) {
           if (j == 2) {
               break@qfxl //或者continue
           } 
            println(j) //只输出1
        }
    }
}

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

标签处返回

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

fun main(args: Array<String>) {
    foo()
}
fun foo():Unit {
    val arrays = arrayOf("a","b","c")
    arrays.forEach {
        if (it == "b") {
            return
        }        
        println(it)// 打印a
    }
}

这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。） 如果我们需要从 lambda 表达式中返回，必须给它加标签并用以限制 return。

fun main(args: Array<String>) {
    foo()
}
fun foo():Unit {
    val arrays = arrayOf("a","b","c")
    arrays.forEach lit@{
        if (it == "b") {
            return@lit
        }        
        println(it) //打印a, c
    }
}

现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。

fun foo():Unit {
    val arrays = arrayOf("a","b","c")
    arrays.forEach {
        if (it == "b") {
            return@forEach
        }        
        println(it)
    }
}

或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回。

fun foo1() {
    val arrays = arrayOf("a", "b", "c")
    arrays.forEach(fun(value: String) {
        if (value == "b") return 
        println(value) //打印a, c
    })
}

摘自：http://www.runoob.com/kotlin/kotlin-loop-control.html