Kotlin 03 控制流

条件判断 if & when

if 表达式

if 的使用和Java中基本一致。不同的是Kotlin中的 if 有返回值，以此来代替Java 中的三元运算符。

一般用法：

fun fun1(name:String){
    if (name=="JOEL"){
        println("我是JOEL")
    }
}

作为表达式用法：

if 作为表达式 将他的值返回或者赋给变量，必须含有 else 分支。

fun fun2(name:String):String{
    return if (name=="JOEL"){
        "我是JOEL"
    }else{
        "我不是JOEL"
    }
}

//和上面的方法相同，只是省略了 花括号
fun fun2(name: String): String {
    return if (name == "JOEL") "我是JOEL" else  "我不是JOEL"
}

if 分支只有一行代码时，可以省略花括号。为代码块时，最后一行代码的执行结果作为返回值。

fun fun3(vararg p0: String?): Int {
    return if (p0 != null) {
        var str = ""
        p0.forEach {
            str += it
        }
        str.length
    } else {
        println("参数为空")
        0
    }
}

when 表达式

when 表达式 和Java中的 switch 类似。when 也有返回值。

一般用法：

fun fun5(p0: Int) {
  when(p0){
      0->{
          println("0")
      }
      1-> println("1")
      2,3->{
          println("p0 is $p0")
      }
  }
}

when分支代码只有一行时，可以省略 花括号（例如分支1）。多个分支使用相同的处理方法时，可以将多个分支条件写在一起，使用逗号分割，例如（分支2，3）。

表达式用法：

when 作为表达式使用，将值返回或者赋给变量时，必须有 else 分支。

fun fun6(p0: Int): String {
    return when (p0) {
        0 -> {
            "参数是0"
        }
        1 ->
            "参数为1"
        2, 3 -> {
            "参数为2 或 3"
        }
        else -> {
            "未知参数"
        }
    }
}

when 表达式 的 分支条件支持任何表达式。

fun fun6(p0: Int): String {
    return when (p0) {
        0 -> {
            "参数是0"
        }
        fun6() ->
            "参数为1"
        "2".toInt(), 3 -> {
            "参数为2 或 3"
        }
        else -> {
            "未知参数"
        }
    }
}

fun fun6():Int{
    return 1
}

in & !in

when 表达式也可以使用 in 或 !in 检查一个值是否在一个区间 或 集合内。

fun fun7(p0: Int):String {
   return when (p0) {
        in 5..10 -> {
            "p0 在区间 0 --- 10 中"
        }
        !in arrayOf(1,2,3,4)->{
            "p0 不在数组中"
        }
        in arrayListOf(1,2,5,8,9,10)->{
            "p0 在 list 中"
        }
        else -> {
            "p0不在任何区间 和 集合中"
        }
    }
}

is & !is

使用 is 或 !is 检查一个对象 是否 属于某个类型, 也可以在 if 语句中使用。

fun fun8(p0:Any){
    when(p0){
        is String ->{
            println("p0 是 String")
        }

        !is String ->{
            println("p0 不是 String")
        }
    }
}

替代if-else if 链

当when没有参数时，每个分支都是简单的Boolean表达式，当一个分支为true时，则执行该分支。

fun fun9() {
    val x = 15
    when {
        x < 10 -> {
            println("x 小于 10")
        }
        //x>10 && x<20
        x in 11..19 -> {
            println("x 大于 10 小于 20")
        }

        x > 20->{
            println("x 大于  20")
        }
    }
}

Java 中的 switch 对比的类型有限。

Kotlin 中的when 可以对比任何类型。

class Person {

}

var person = Person()
var person1 = Person()
fun fun10(p0: Person) {
    when (p0) {
        person -> {
            println("p0 is person")
        }
        person1 -> {
            println("p0 is person1")
        }
    }
}

var array = arrayOf("1", "2", "3")
var array1 = arrayOf("1", "2", "3", "4")
fun fun11(p0: Array<String>) {
    when (p0) {
        array -> {
            println("p0 is array")
        }
        array1 -> {
            println("p0 is array1")
        }

        else -> {
            println("啥也不是")
        }
    }
}

循环语句 for & while

for

for 可以遍历任何提供了迭代器（iterator）的对象。

语法

for(元素 in 集合){
    代码块
}

fun main() {
    val strList = arrayListOf("1","2","3","4")
    for (str in strList){
        println(str)
    }
}

索引

for 循环中获取索引的方式有两种

1，调用 集合 的 indices 属性

val strList = arrayListOf("1","2","3","4")
for (index in strList.indices){
    println(index)
}

index 即为 集合中元素的索引

2，使用库函数withIndex

val strList = arrayListOf("1","2","3","4")
//index 为索引 value 为 索引 对应的值
for ((index,value) in strList.withIndex()){
    println("$index ----- $value")
}

while

Kotlin 中的 while、do..while 和 Java 中 使用一致。

fun main() {
    var x = 0
    while (x<10){
        x++
        println(x)
    }

//    var y = 0
    var y = 10
    do {
        y++
        println(y)
    } while (y < 10)