Kotlin循环控制

<1>for循环可以对任何提供迭代器的对象进行遍历，如下：

 for (item in collection) print(item)

<2>循环体也可以是一个代码块

val ints = arrayOf(1,2,3)
for (item:Int in ints){
    Log.i("aaaaaa",item.toString())
}

输出：I/aaaaaa: 1

I/aaaaaa: 2

I/aaaaaa: 3

<3>如果你想通过索引遍历一个数组或者一个List，可以如下

val list2 = mutableListOf("a")
list2.add("b")
list2.add("c")
for (i in list2.indices){
    Log.i("aaaaaa",list2.get(i))
}

输出：aaaaaa: a

aaaaaa: b

aaaaaa: c

注意，这种在区间上遍历会编译成优化的实现而不会创建额外的对象。

<4>两个实例

//实例1
val items = listOf("apple","banana","kiwi")
for (item in items){
    Log.i("aaaaaa",item)
}

输出：aaaaaa: apple

          aaaaaa: banana

          aaaaaa: kiwi

//实例2
val items = listOf("apple","banana","kiwi")
for (index in items.indices){
    Log.i("aaaaaa","item at $index is ${items[index]}")
}

输出：item at 0 is apple

           item at 1 is banana

           item at 2 is kiwi

<1>while基本结构

while(布尔表达式){
    //循环内容
}

<2>do...while基本结构

do{
    //循环语句
}while(布尔表达式)

它的特点是，即使不满足条件，循环语句也会执行一次。

<1>Kotlin的三种结构化跳转表达式

return：默认从最直接包围它的函数或者匿名函数返回

break：终止最直接包围它的循环

continue：继续下一次最直接包围它的循环

<2>使用标签限制break和continue

未使用标签示例：

for (i in 1..3){
    Log.i("aaaaaa","i:"+i)
    for (j in 1..3){
        Log.i("aaaaaa","j:"+j)
        if (j == 2){
            break
        }
    }
}

输出日志如下：

I/aaaaaa: i:1
I/aaaaaa: j:1
I/aaaaaa: j:2
I/aaaaaa: i:2
I/aaaaaa: j:1
I/aaaaaa: j:2
I/aaaaaa: i:3
I/aaaaaa: j:1
I/aaaaaa: j:2

使用标签示例：

loop@for (i in 1..3){
    Log.i("aaaaaa","i:"+i)
    for (j in 1..3){
        Log.i("aaaaaa","j:"+j)
        if (j == 2){
            break@loop
        }
    }
}

输出日志如下：

I/aaaaaa: i:1
I/aaaaaa: j:1
I/aaaaaa: j:2

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

<3>不同return的用法

================================第一种================================

fun foo(){
    ints.forEach {
        if (it == 4) return
        Log.i("aaaaaa",it.toString())
    }
    Log.i("aaaaaa","finish")
}

输出如下：

I/aaaaaa: 1
I/aaaaaa: 2
I/aaaaaa: 3

这个return表达式从最直接包围它的函数即foo中返回。

==============================第二种================================

fun foo(){
    ints.forEach lit@{
        if (it == 4) return@lit
        Log.i("aaaaaa",it.toString())
    }
    Log.i("aaaaaa","finish")
}

输出如下

I/aaaaaa: 1
I/aaaaaa: 2
I/aaaaaa: 3
I/aaaaaa: 5
I/aaaaaa: finish

这个只会从lambda表达式中返回，并执行之后的循环

===========================第三种============================

fun foo(){
    ints.forEach{
        if (it == 4) return@forEach
        Log.i("aaaaaa",it.toString())
    }
    Log.i("aaaaaa","finish")
}

输出与第二种相同

I/aaaaaa: 1
I/aaaaaa: 2
I/aaaaaa: 3
I/aaaaaa: 5
I/aaaaaa: finish

这是简单写法，但要求标签与该lambda函数同名，或使用匿名函数，return语句将会从函数内部的匿名函数自身返回。示例如下

fun foo(){
    ints.forEach(fun(value:Int){
        if (value == 4) return@forEach
        Log.i("aaaaaa",value.toString())
    })
    Log.i("aaaaaa","finish")
}