一起来学Kotlin：概念：8. Kotlin Control Flow: When, For, While, Range 等使用

一起来学Kotlin：概念：8. Kotlin Control Flow: When, For, While, Range 等使用

这里，我们将逐一介绍 When, For, ForEach, While, Do-While, Range: .. 等使用。

---

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

---

1 When

Kotlin中，when 代替了广泛使用的 switch 语句，在构造时提供了更加灵活和清晰的方式。 它既可以用作语句，也可以用作表达式。

fun main() {
    cases("Hello")
    cases(1)
    cases(0L)
    cases(MyClass())
    cases("hello")
}

fun cases(obj: Any) {                                
    when (obj) {                                       
        1 -> println("One")                          
        "Hello" -> println("Greeting")               
        is Long -> println("Long")                   
        !is String -> println("Not a string")        
        else -> println("Unknown")                   
    }   
}

class MyClass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

需要注意的是，when 中的所有语句会逐条遍历，直到某一项得到满足。

以下是另一个 when 使用的例子：

fun main() {
    println(whenAssign("Hello"))        // 打印 1
    println(whenAssign(3.4))            // 打印 42
    println(whenAssign(1))              // 打印 one
    println(whenAssign(MyClass()))      // 打印 42
}

fun whenAssign(obj: Any): Any {
    val result = when (obj) {                   
        1 -> "one"                              
        "Hello" -> 1                            
        is Long -> false                        
        else -> 42                              
    }
    return result
}

class MyClass
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2 For, ForEach

在这里，我们可以对 For Loop 和 ForEach Loop 进行一些介绍和比较：

// For loop
for (i in 0..10) { println(i) }
// ForEach
(0..10).forEach { println(it) }
1
2
3
4

上述两个表达方式是等效的。

如果数据源是一个可迭代的集合，那么 forEach 会更好，因为它可以链接在一起。

// For loop
val list = listOf(1, 2, 3).filter( it == 2 )
for (i in list) { println(i) }
// ForEach
listOf(1, 2, 3).filter( it == 2 ).forEach { println(it) }
1
2
3
4
5

对于 continue 和 break 来说，For 可能是更加适合的选择。

// For loop
for (i in 0 until 10 step 3) {
    if (i == 6) continue
    println(i)
}
// ForEach
(i in 0 until 10 step 3).forEach {
    if (it == 6) return@forEach
    println(it)
}
// For loop
for (i in 0 until 10 step 3) {
    if (i == 6) break
    println(i)
}
// ForEach (result is wrong though)
(i in 0 until 10 step 3).forEach {
    if (it == 6) return
    println(it)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

我们可以在 For 循环中使用 break，但对于 forEach，它可以尝试的最接近的是 return，这并不正确，因为它将完全退出其包含的函数，而不是在 for 循环之外继续。所以，如果遇到 break 和 continue 的情况，For是最好的选择。

如果我们希望 For 循环中带有 index，可以这么写：

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

或者

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

对于 ForEach 来说，等价的表述方式是：

collection.forEachIndexed { index, element ->
    // ...
}
1
2
3

3 While, Do-while

fun eatACake() = println("Eat a Cake")
fun bakeACake() = println("Bake a Cake")

fun main(args: Array<String>) {
    var cakesEaten = 0
    var cakesBaked = 0
    
    while (cakesEaten < 5) {                    
        eatACake()
        cakesEaten ++
    }
    
    do {                                        
        bakeACake()
        cakesBaked++
    } while (cakesBaked < cakesEaten)

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

返回：

Eat a Cake
Eat a Cake
Eat a Cake
Eat a Cake
Eat a Cake
Bake a Cake
Bake a Cake
Bake a Cake
Bake a Cake
Bake a Cake
1
2
3
4
5
6
7
8
9
10

While 和 Do-while 和其他语言没什么区别，这里就不详细介绍了。

4 Iterator 运算符

我们可以通过在类中实现迭代器运算符来在类中定义自己的迭代器。

class Animal(val name: String)

class Zoo(val animals: List<Animal>) {

    operator fun iterator(): Iterator<Animal> {             
        // 在类中定义一个迭代器。 它必须被命名为迭代器并具有操作符修饰符。
        return animals.iterator()                           
        // 返回满足以下方法要求的迭代器：- next(): Animal; - hasNext(): Boolean
    }
}

fun main() {

    val zoo = Zoo(listOf(Animal("zebra"), Animal("lion")))

    // 使用用户定义的迭代器循环遍历
    for (animal in zoo) {                                   
        println("Watch out, it's a ${animal.name}")
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

5 Ranges “…” 的使用

// 数字的使用
for(i in 0..3) {             
    print(i)
}
// 从 0 到 3（包含3）的迭代。就像其他编程语言 (C/C++/Java) 中的 'for(i=0; i<=3; ++i)'。
print(" ")

for(i in 0 until 3) {       
    print(i)
}
// 从 0 到 3（不包含3）的迭代。
print(" ")

for(i in 2..8 step 2) {    
    print(i)
}
print(" ")

for (i in 3 downTo 0) {    
    print(i)
}
print(" ")
// 上述打印结果显示：0123 012 2468 3210 

// char的使用
for (c in 'a'..'d') {        // 1
    print(c)
}
print(" ")

for (c in 'z' downTo 's' step 2) { // 2
    print(c)
}
print(" ")
// 上述打印结果显示：abcd zxvt 

// 和if放在一起使用
val x = 2
if (x in 1..5) {            // 1
    print("x is in range from 1 to 5")
}
println()

if (x !in 6..10) {          // 2
    print("x is not in range from 6 to 10")
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

6 Equality Checks

Kotlin 使用 == 进行结构比较，使用 === 进行引用比较。

val authors = setOf("Shakespeare", "Hemingway", "Twain")
val writers = setOf("Twain", "Shakespeare", "Hemingway")

println(authors == writers)   // Returns true because it calls authors.equals(writers) and sets ignore element order.
println(authors === writers)  // Returns false because authors and writers are distinct references.
1
2
3
4
5