Kotlin---控制流程

None_Ling

发布于 2018-12-05 15:41:31

4190

发布于 2018-12-05 15:41:31

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