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

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

包

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

package com.gyg.kolin

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

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

控制流

if表达式

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

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

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

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

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

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

val a:Int=23
val b:Int=46
val max:Int
if(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)”。