本文将伴随大家进入Kotlin语言的正式学习生涯中，希望大家不要半途而废哦！笔者将Kotlin用于Android开发中，因此将从Android开发的视角叙述相关内容，同时将与Java语言有所联系。

1. 条件控制语句

1.1 if条件语句

一个 if 语句包含一个布尔表达式和一条或多条语句，完全兼容Java的使用方式，一个if关键字可匹配最多一个else关键字和多个else if关键字。

1
2
3
4
5
6
7
8
9
10
11
12
13
// 传统用法
var max = a
if (a < b) max = b

// 使用 else 和 else if
var max: Int
if (a > b) {
    max = a
} else if (a < b) {
    max = b
} else {
    max = a
}

Kotlin还具有一个很方便的特性，if表达式可以将结果(执行语句块中的最后一行需为常量值或变量值)直接赋值给一个变量，这也说明我也不需要像Java那种有一个三元操作符? :，因为我们可以使用if来简单实现。

1
2
3
4
5
6
7
8
9
10
11
// 一般用法
val max = if (a > b) {
    print("Choose a")
    a
} else {
    print("Choose b")
    b
}

// 用于取代Java中的三元操作符 ? :
val max = if (a > b) a else b

1.2 when条件语句

when将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。

when类似其他语言的switch操作符。其最简单的形式如下：

1
2
3
4
5
6
7
when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    else -> {
        print("x 不是 1 ，也不是 2")
    }
}

在when中，else同switch的default。如果其他分支都不满足条件将会求值else分支。

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

1
2
3
4
when (x) {
    0, 1 -> print("x == 0 or x == 1")
    else -> print("otherwise")
}

when也可以用来取代if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：

1
2
3
4
5
when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

2. 循环控制语句

2.1 for循环语句

for循环可以对任何提供迭代器iterator的对象进行遍历，条件的指定用的是in运算符来确定循环次数（关于in运算符的其他用法可看本文3.2.1 in运算符），语法为for (item in collection) print(item)，循环体可以是一个代码块:

1
2
3
for (item: Int in ints) {
    // ……
}

如上所述，for可以循环遍历任何提供了迭代器的对象，使用方式与Java中的foreach语句非常相像。如果你想要通过索引遍历一个数组或者一个list，你可以这么做：

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

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

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

而要达成在Java中平常经常使用的形式，需要使用区间来完成：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 正常循环：
for (i in 1..4) print(i) // 打印结果为: "1234"

// 如果你需要按反序遍历整数可以使用标准库中的 downTo() 函数:
for (i in 4 downTo 1) print(i) // 打印结果为: "4321"

// 也支持指定步长：
for (i in 1..4 step 2) print(i) // 打印结果为: "13"

for (i in 4 downTo 1 step 2) print(i) // 打印结果为: "42"

// 如果循环中不要最后一个范围区间的值可以使用 until 函数:
for (i in 1 until 4) print(i) // 打印结果为: "123"

2.2 while与do…while循环语句

while是最基本的循环，它的结构为：

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

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

1
2
3
do {
       //代码语句
}while(布尔表达式);

实例

1
2
3
4
5
6
7
8
9
10
11
12
fun main(args: Array<String>) {
    println("----while 使用-----")
    var x = 5
    while (x > 0) {
        print( x--)
    }
    println("----do...while 使用-----")
    var y = 5
    do {
        print(y--)
    } while(y>0)
}

输出结果：

1
2
3
4
----while 使用-----
54321
----do...while 使用-----
54321

3. 其他控制语句

3.1 返回和跳转

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
fun main(args: Array<String>) {
    for (i in 1..10) {
        if (i==3) continue  // i 为 3 时跳过当前循环，继续下一次循环
        println(i)
        if (i>5) break   // i 为 6 时 跳出循环
    }
}

//输出结果：
1
2
4
5
6

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

1
2
3
4
5
loop@ for (i in 1..100) {
    for (j in 1..100) {
        if (……) break@loop
    }
}

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

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

1
2
3
4
5
6
fun foo() {
    ints.forEach {
        if (it == 0) return
        print(it)
    }
}

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

1
2
3
4
5
6
fun foo() {
    ints.forEach lit@ {
        if (it == 0) return@lit
        print(it)
    }
}

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

1
2
3
4
5
6
fun foo() {
    ints.forEach {
        if (it == 0) return@forEach
        print(it)
    }
}

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

1
2
3
4
5
6
fun foo() {
    ints.forEach(fun(value: Int) {
        if (value == 0) return
        print(value)
    })
}

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

1
return@a 1

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

3.2 条件指定的几种特殊方式

3.2.1 in运算符

使用in运算符来检测某个数字是否在指定区间内，区间格式为x..y。

1
2
3
4
5
6
7
8
9
10
fun main(args: Array<String>) {
    val x = 5
    val y = 9
    if (x in 1..8) {
        println("x 在区间内")
    }
    when (y) {
        in 1..10 -> print("y 在区间内")
    }
}

输出结果为：

1
2
x 在区间内
y 在区间内

in运算符也可以用来检测某个元素是否存在于指定集合或列表中。

1
2
3
4
5
6
7
8
9
10
fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    if ("banana" in items) {
        println("香蕉")
    }
    when {
        "orange" in items -> println("橘子")
        "apple" in items -> println("苹果")
    }
}

输出结果为：

1
2
香蕉
苹果

3.2.2 is运算符

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

1
2
3
4
5
6
7
8
9
10
11
fun main(args: Array<String>) {
    val x = "string obj 1"
    val y = "string obj 2"
    if (x !is Int) {
        println("x不是整型")
    }
    when (y) {
        is String -> println("y是字符串")
        else -> false
    }
}

输出结果为：

1
2
x不是整型
y是字符串