if-else表达式
在if-else的控制流中，可以使用表达是来获取结果，也可以通过闭包来获取表达式结果
class TestKotlin {
fun function() {
var x: Int = 10
var y: Int = 20;
// z取x,y中的较大值
var z = if (x > y) x else y
// 打印日志后返回值
var m = if (x > y) {
println("x > y:$x")
x
} else {
println("x < y:$y")
y
}
}
}
When表达式
When表达式取代了Java和C中的switch。但是比switch的能力强很多，在控制流程中可以加入表达式来辅助判断分支逻辑
class TestKotlin {
fun function(input: Int) {
when (input) {
// 会优先执行表达式，然后再将输入匹配表达式结果，满足则执行该分支
processInput(input) -> Log.e("Kotlin", "input x % 3:${processInput(input)} ")
// in 关键字可以用来判断是否在某段区间，此处表示在1-2的区间内则走该分支
in 1..2 -> Log.e("Kotlin", "input in 1-2:$input")
// 除了表达式之外，还可以使用闭包
in 4..6 -> {
Log.e("Kotlin", "input in 4-6:$input")
}
// 最后需要有else，相当于default
else -> {
Log.e("Kotlin", "input else :$input")
}
}
}
fun processInput(x: Int): Int {
// 此处如果能被3整除，则返回输入，否则返回0
return if (x % 3 == 0) x else 0
}
}
与Java和C不同的是，在when的控制流程中，不可以使用continue以及break，这两个关键字只能在Loop中使用。但是在函数中，return也还是可以随便使用的。
for循环
对于Map的遍历有两种方式
class TestKotlin {
fun function() {
val map: Map<A, B> = mapOf(A(1) to B(1), A(2) to B(2), A(3) to B(3))
// 通过Key-Value的方式遍历Map
for ((k, v) in map) {
Log.e("Kotlin", "Key :${k.x}....Value:${v.x}")
}
// 通过Item的方式遍历Map
for (item in map) {
Log.e("Kotlin", "item Key:${item.key.x}....Value:${item.value.x}")
}
}
class A(var x: Int)
class B(var x: Int)
}
对于List的遍历方式，通过Iterator的方式可以获得Item，而通过IndexingIterable的方式，可以获得Index以及Item
class TestKotlin {
fun function() {
val list: List<A> = listOf(A(1), A(2), A(3), A(4))
// Iterator
for (item in list) {
Log.e("Kotlin", "item :${item.x}")
}
// IndexingIterator
for ((index, item) in list.withIndex()) {
Log.e("Kotlin", "index:$index....Item:${item.x}")
}
}
class A(var x: Int)
}
而for循环中，也可以使用continue以及``break```，简单的用法和Java、c的作用相同：
class TestKotlin {
fun function() {
val list: List<A> = listOf(A(1), A(2), A(3), A(4))
for (item in list) {
if (item.x == 2) {
continue
}
if (item.x == 3) {
break
}
Log.e("Kotlin", "Item:${item.x}")
}
}
class A(var x: Int)
}
而Kotlin中，多重循环可以通过lable的形式与continue以及break配合进行多重循环内部的跳转：lable只能声明在循环前
- continue+lable：跳转到该lable，并且继续下一次循环
- break + lable：跳出该lable的循环，执行下一条指令
首先来看一下：在以下代码声明了loop@以及insideloop@两个标签声明在for循环前。而当循环遍历list的时候，如果遇到2时，则继续内部循环。而如果遇到3时，则跳出整个外部循环。
class TestKotlin {
fun function() {
val list: List<A> = listOf(A(1), A(2), A(3), A(4))
loop@ for (i in list.size downTo 1) {
insideloop@for (item in list) {
if (item.x == 2) {
Log.e("Kotlin", "i:$i....Item:${item.x}: continue to insideloop")
continue@insideloop
}
if (item.x == 3) {
Log.e("Kotlin", "i:$i....Item:${item.x}: break to loop")
break@loop
}
Log.e("Kotlin", "i:$i....Item:${item.x}")
}
}
}
class A(var x: Int)
}
这段代码输出结果如下：
i:4....Item:1
i:4....Item:2: continue to insideloop
i:4....Item:3: break to loop
而如果如果改成break@insideloop的话，则会输出：
i:4....Item:1
i:4....Item:2: continue to insideloop
i:4....Item:3: break to loop
i:3....Item:1
i:3....Item:2: continue to insideloop
i:3....Item:3: break to loop
i:2....Item:1
i:2....Item:2: continue to insideloop
i:2....Item:3: break to loop
i:1....Item:1
i:1....Item:2: continue to insideloop
i:1....Item:3: break to loop
区间
之前使用过in关键字，来判断数字的区间以及是否在列表中。上面使用了downto关键字是用来反向输出的。例如：
class TestKotlin {
fun function() {
val list: List<A> = listOf(A(1), A(2), A(3), A(4))
for (i in list.size downTo 1 step 2) {
Log.e("Kotlin", "i:$i")
}
}
}
class A(var x: Int)
其中list.size downTo 1会输出4,3,2,1，而step 2则是会每次移动两个元素，所以输出的结果会是4，2
i:4
i:2
网友评论