Kotlin学习笔记（二）循环，跳转

提示：本文为作者阅读Kotlin中文站学习笔记，建议读者移步Kotlin中文站完整学习。

包

源文件通常以包声明开头，源文件所有内容都包含在声明的包内，如果没有声明包，文件内容属于无声明的默认包。当我们创建一个Kotlin文件时，Android studio会帮我们在文件顶部自动声明包。

package com.gyg.kolin

Kotlin会默认导入一些包到文件中，除了默认导入的包，开发者也需要导入自己的包，可以单独导入包下的某一个内容，也可以导入包下的所有内容。当命名冲突时，可以通过as关键字在本地重命名来消除歧义。

import foo.Bar//导入foo包下的Barimport foo.*//导入foo包下的所有内容import foo.Bar as Bar2//导入foo包下的额Bar，并且本地重命名为Bar2

控制流

if表达式

在Kotlin中，if是一个表达式，它可以返回一个值。

val a:Int=23val b:Int=46val max:Intmax=if(a>b) a else b//if作为一个表达式，当a>b时返回值a,否则返回值b

if的分支也可以是一个代码块，最后的表达式为该块的值

val a:Int=23val b:Int=46val max:Intmax=if(a>b){    print("max="+a)    a}else{    print("max="+b)    b}

注意：如果if作为一个表达式使用，除非编译器能够检测出所有的可能情况都已经覆盖了，否则必须有else分支。

我们也可以像Java中一样，把if作为一个语句使用

val a:Int=23val b:Int=46val max:Intif(a>b){    max=a}else{    max=b}

when表达式

when表达式，与Java中的switch语句类似。when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。它可以被当作表达式使用， 符合条件的分支的值就是整个表达式的值。（像 if 一样，每一个分支可以是一个代码块，它的值是块中最后的表达式的值。）例如：

val a: Int = 3    val b: Int = 5    var max: Int    max = when (a > b) {        true -> {            print("max=a")            a        }        false -> {            print("max=b")            b        }        else -> {            print("a=b")            a        }    }

也可以当做语句使用， 忽略个别分支的值。

val a:Int=3    val b:Int=5    var max:Int    when(a>b){        true->{            print("max=a")            max=a        }        false->{            print("max=b")            max=b        }        else->{            print("a=b")            max=a        }    }

如果其他分支都不满足条件将会求值 else 分支。 如果 when 作为一个表达式使用，则必须有 else 分支， 除非编译器能够检测出所有的可能情况都已经覆盖了。

如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

var x:Int=0    when(x){        0,1-> print("x==1或x==2")        else-> print("otherwise")    }

我们可以用任意表达式（而不只是常量）作为分支条件

when (x) {    parseInt(s) -> print("s encodes x")    else -> print("s does not encode x")}

我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

val x:Int=5    val values:IntArray= intArrayOf(0,5,7,9)    when(x){        in 0..10->{//区间            print("x is in 0..10")        }        in values->{//集合            print("x is in values")        }    }

另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。注意： 由于智能转换，你可以访问该类型的方法和属性而无需任何额外的检测。

fun getType(value:Any):Unit{        when(value){            is String-> print("value is a String type")            is Int-> print("value is Int type")            else-> print("value is not a String type or Int type")        }    }

如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

when {    x.isOdd() -> print("x is odd")    x.isEven() -> print("x is even")    else -> print("x is funny")}

For循环

for循环可以对任何提供迭代器（iterator）的对象进行遍历，即这个对象：

• 有一个成员函数或者扩展函数iterator()，它的返回类型

  • 有一个成员函数或扩展函数next()，返回这个对象的成员元素。并且
  • 有一个成员函数或者扩展函数hasNext()返回Boolean。

  这三个函数都要标记为operator。

val str:String="Hello world"    for (item in str) print(item)

对数组的 for 循环会被编译为并不创建迭代器的基于索引的循环。
如果你想要通过索引遍历一个数组或者一个 list，你可以这么做：

for (i in array.indices) {    print(array[i])}

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

for ((index, value) in array.withIndex()) {    println("the element at $index is $value")}

While循环

我们可以以在Java中的相同姿势来在Kotlin中使用while循环和do..while循环。

while (x > 0) {    x--}do {  val y = retrieveData()} while (y != null) // y 在此处可见

返回和跳转

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

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

这些表达式的类型都是Nothing类型。
所有这些表达式可以作为包含它的更大表达式的一部分:

val name=person.name?:return

Break，Continue标签

Kotlin中，我们可以用标签来标记一个表达式，标签的格式为：标签字符后跟@符号，例如：abc@，foreach@等等。要为一个表达式加标签，我们只要在其前加标签即可。

abc@ for (item in str) print(item)

我们可以用标签来限制break和continue表达式：

outer@for (i in 0..10){        innrer@for (j in 0..10){            if (i==3&&j==3)continue@outer            if (i==5&&j==5) break@outer        }    }

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

标签处返回

Kotlin中，return语句是从最直接包含它的fun标记的函数中返回，例如下面这样：

fun foo() {    ints.forEach {        if (it == 0) return        print(it)    }}

ruturn 直接从foo()函数中返回，如果我们要从lambda表达式中返回，必须给它加标签并用以限制return表达式：

fun foo() {    ints.forEach @lambda{        if (it == 0) return@lambda        print(it)    }}

这样，return就会从lambda函数中返回。或者更方便的，我们可以使用隐式标签，它与接受该lambda表达式的函数同名：

fun foo() {    ints.forEach {        if (it == 0) return@forEach        print(it)    }}

或者，我们用匿名函数来代替lambda表达式，匿名函数里的return表达式，将直接从该匿名函数中返回。

fun foo() {    ints.forEach(fun(value: Int) {        if (value == 0) return        print(value)    })}

当要返回一个值的时候，解析器优先选用标签限制的 return，即

return@a 1

意为“从标签 @a 返回 1”，而不是“返回一个标签标注的表达式 (@a 1)”。