Kotlin学习笔记——控制流和跳转

if表达式

// Traditional usage 
var max = a 
if (a < b) 
  max = b 

// With else 
var max: Int
if (a > b) 
  max = a 
else 
  max = b 

// As expression 
val max = if (a > b) a else b

// the last expression is the value of a block
val max = if (a > b) { 
    print("Choose a") 
    a 
  } 
  else { 
    print("Choose b") 
    b 
  }

When表达式

在Java中，我们经常使用switch语句，在Kotlin里面，把它简化成了when表达式

when (x) {
  1 -> print("x == 1")
  2 -> print("x == 2")
  else -> { // Note the block
    print("x is neither 1 nor 2")
  }
}

它会从上到下进行比较，直到匹配到一个符号的就执行后面的语句，然后结束，如果没有匹配的，就执行else后面的语句。

如果有多个case需要同时匹配，可以使用下面的这种方式结合。

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

对于前面的case可以使用表达式

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

也可以检查一个值是否在某个区间

when (x) {
  in 1..10 -> print("x is in the range")
  in validNumbers -> print("x is valid")
  !in 10..20 -> print("x is outside the range")
  else -> print("none of the above")
}

可以检查一个值是否为某种类型

val hasPrefix = when(x) {
  is String -> x.startsWith("prefix")
  else -> false
}

when表达也可以替代if-else if语句

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

// 等同于

if (x.isOdd())
        print("x is odd")
    else if (x.isEven())
        print("x is even")
    else
        print("x is funny")

For循环表达

循环遍历某个集合

for (item in collection)
  print(item)

for (item: Int in ints) {
  // ...
}

for可以遍历任何提供了iterator对象的集合。

var array: Array<Int> = arrayOf(1,2,3,4,5)
var iterator: Iterator<Int> = array.iterator()
while (iterator.hasNext())
    print(iterator.next())

// 等同于

var array: Array<Int> = arrayOf(1,2,3,4,5)
for (num:Int in array)
    print(num)

如果希望以索引的方式进行遍历

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

同时访问一个集合的键值对

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

While循环

while和do..while的形式

while (x > 0) {
  x--
}

do {
  val y = retrieveData()
} while (y != null) // y is visible here!

返回和跳转

跟Java一样有三种跳转方式：return、break、continue。

与Java不同的是，它加入了标签元素，使得跳转具有了一定的灵活性。

@loop for (i in 1..100) {
  ...
}

我们知道：
return是跳出当前函数
break是跳出循环
continue是跳出本次循环，进入下一次循环

如果有多重循环，带标签的break会跳转出标签所指示的那一个循环。带标签的continue会跳转到标签所指向的那个循环,进入该循环的下一次循环。

@loop for (i in 1..100) {
  for (j in 1..100) {
    if (..)
      break@loop
  }
}

上面的这个会跳出这个双重循环。

在Kotlin中，函数也是有内嵌层级的。 而带标签的return让我们可以指定返回的目标。

带标签的return，最重要的一个用途，就是让我们可以从函数字面量中返回。

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

上面这个函数返回，是从foo()返回，结束整个foo()循环。如果我们想只从函数字面量里返回，则需要加上标签：

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

还有更简单的写法，就是使用隐式标签：函数名

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

有名字的函数，自动定义标签(和函数同名)：

fun outer() {
  fun inner() {
    return@outer // 标签outer自动定义了
  }
}

return语句在匿名函数里面返回，只是返回匿名函数本身

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

如果需要在返回的时候带有一个值。

return@a 1

会被认为是”在标签@a上返回1”，而不是”返回一个带标签的表达式(@a 1)”。

参考文章：
Control Flow
Returns and Jumps