Kotlin学习系列——控制流程

灰太狼 2023-06-25 10:23 83阅读 0赞

官方文档: http://kotlinlang.org/docs/reference/control-flow.html

1.if语句/if表达式

  1. 在 Kotlin 中，if可作为表达式，即可返回一个值！
  2. 因此 Kotlin 没有三元运算符( a>b ? a : b )，因为if表达式就能胜任( if (a > b) a else b )
  4. // 1.传统用法,作为if语句
  5.     var max: Int
  6.     if (a > b) {
  7.         max = a
  8.     } else {
  9.         max = b
  10.     }
  12. // 2.作为if表达式
  13.     注意：如果if作为表达式，显然必需要有else分支，因为表达式在任何情况下都应有返回值！
  14.     val max = if (a > b) a else b
  16.     if分支还可以是代码块，最后一行的表达式作为代码块的返回值：
  17.     val max = if (a > b) {
  18.                     print("Choose a")
  19.                     a
  20.                 } else {
  21.                     print("Choose b")
  22.                     b
  23.                 }
  29.    1
  30.    2
  31.    3
  32.    4
  33.    5
  34.    6
  35.    7
  36.    8
  37.    9
  38.    10
  39.    11
  40.    12
  41.    13
  42.    14
  43.    15
  44.    16
  45.    17
  46.    18
  47.    19
  48.    20
  49.    21
  50.    22
  51.    23

2.when语句/when表达式

  1. when将参数和分支条件进行顺序比较，直到某个分支满足条件！
  2. 像if一样, when即可作为语句，也可作为表达式！
  3. 如果when作为表达式, 则符合条件的分支值就是整个表达式值, 如果都不满足则会求值else分支;    
  4. 如果when作为表达式，显然必需要有else分支, 除非编译器检测出已覆盖所有可能分支!
  6. when语句取代了类C语言/java的switch语句:
  7.     when (x) {
  8.         1 -> print("x == 1")
  9.         2 -> print("x == 2")
  10.         else -> { // 注意这个块
  11.             print("x is neither 1 nor 2")
  12.         }
  13.     }
  15. 1.多个分支代码相同,可放在一起,用逗号分隔:
  16.     when (x) {
  17.         0, 1 -> print("x == 0 or x == 1")
  18.         else -> print("otherwise")
  19.     }
  21. 2.可用任意表达式(不只是常量)作为分支条件:
  22.     when (x) {
  23.         parseInt(s) -> print("s encodes x")
  24.         else -> print("s does not encode x")
  25.     }
  27. 3.可检测一个值在(in)或者不在(!in)一个区间或集合：
  28.     when (x) {
  29.         in 1..10 -> print("x is in the range")
  30.         in validNumbers -> print("x is valid")
  31.         !in 10..20 -> print("x is outside the range")
  32.         else -> print("none of the above")
  33.     }
  35. 4.可检测一个值是(is)或不是(!is)某种类型:
  36.     fun hasPrefix(x: Any) = when(x) {
  37.         is String -> x.startsWith("prefix")
  38.         else -> false
  39.     }
  42. 5.取代 if-else if 链 
  43. 如果没有参数，则分支条件结果是 Boolean 类型
  44.     when {
  45.         x.isOdd() -> print("x is odd")
  46.         x.isEven() -> print("x is even")
  47.         else -> print("x is funny")
  48.     }
  54.    1
  55.    2
  56.    3
  57.    4
  58.    5
  59.    6
  60.    7
  61.    8
  62.    9
  63.    10
  64.    11
  65.    12
  66.    13
  67.    14
  68.    15
  69.    16
  70.    17
  71.    18
  72.    19
  73.    20
  74.    21
  75.    22
  76.    23
  77.    24
  78.    25
  79.    26
  80.    27
  81.    28
  82.    29
  83.    30
  84.    31
  85.    32
  86.    33
  87.    34
  88.    35
  89.    36
  90.    37
  91.    38
  92.    39
  93.    40
  94.    41
  95.    42
  96.    43
  97.    44
  98.    45
  99.    46
  100.    47
  101.    48

3.循环

在循环中 Kotlin 支持传统的 break 和 continue

1.for循环

  1. for 可循环遍历提供了迭代器的对象:
  2.     有一个成员函数或者扩展函数 iterator()，
  3.     它的返回类型:
  4.         有一个成员函数或者扩展函数 next(),
  5.         并且有一个成员函数或者扩展函数 hasNext(), 返回 Boolean
  6.     这三个函数都需要标记为 operator
  8.     for (item in collection) {
  9.         print(item)
  10.     }
  12. 也可以通过索引遍历数组或者list:
  13.     for (i in array.indices) {
  14.         print(array[i])
  15.     }
  17. 还可以用库函数 withIndex:
  18.     for ((index, value) in array.withIndex()) {
  19.         println("the element at $index is $value")
  20.     }
  26.    1
  27.    2
  28.    3
  29.    4
  30.    5
  31.    6
  32.    7
  33.    8
  34.    9
  35.    10
  36.    11
  37.    12
  38.    13
  39.    14
  40.    15
  41.    16
  42.    17
  43.    18
  44.    19
  45.    20

实例
对集合进行迭代：

  1. fun main(args: Array<String>) { 
  2.     val items = listOf("apple", "banana", "kiwi")
  3.     for (item in items) { 
  4.         println(item)
  5.     }
  7.     for (index in items.indices) { 
  8.         println("item at $index is ${ items[index]}")
  9.     }
  10. }

输出结果：

  1. apple
  2. banana
  3. kiwi
  4. item at 0 is apple
  5. item at 1 is banana
  6. item at 2 is kiwi

2.while循环

  1. while 和 do..while 和java一样:
  2.     while (x > 0) {
  3.         x--
  4.     }
  6.     do {
  7.         val y = retrieveData()
  8.     } while (y != null) // y 在此处可见
  14.    1
  15.    2
  16.    3
  17.    4
  18.    5
  19.    6
  20.    7
  21.    8

实例：

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

输出结果：

  1. 5
  2. 4
  3. 3
  4. 2
  5. 1
  6. ----do...while 使用-----
  7. 5
  8. 4
  9. 3
  10. 2
  11. 1

官方文档: http://kotlinlang.org/docs/reference/returns.html

3. 返回和跳转

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

return。默认从最直接包围它的函数或者匿名函数返回。
break。终止最直接包围它的循环。
continue。继续下一次最直接包围它的循环。
在循环中 Kotlin 支持传统的 break 和 continue 操作符。

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

输出结果：

  1. 1
  2. 2
  3. 4
  4. 5
  5. 6

和Java不同的是，这些表达式都可作为更大表达式的一部分:

  1. val s = person.name ?: return

4. break和continue @标签

  1. 和Java不同的是，在 Kotlin 中任何表达式都可以用 标签@ 来标记:
  2.     loop@ for (i in 1..100) {
  3.         for (j in 1..100) {
  4.             if (……) break@loop // 终止loop标记的循环
  5.             if (……) continue@loop // 跳出loop标记的循环，继续下一次loop标记的循环
  6.         }
  7.     }
  13.    1
  14.    2
  15.    3
  16.    4
  17.    5
  18.    6
  19.    7

5. return @标签

Kotlin 有局部函数，因此Kotlin函数可被嵌套

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

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

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

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

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

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

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

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

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

  1. return@a 1  // 从@a标记的函数返回1，不是返回标记的表达式(@a 1)”。

发表评论

表情：
评论列表 （有 0 条评论，83人围观）

还没有评论，来说两句吧...

相关阅读