koltin(四) 逻辑控制 if when 循环

luoj_616

已于 2022-10-23 15:29:30 修改

阅读量1.1k

点赞数 2

分类专栏： Kotlin 文章标签： kotlin android java

于 2022-08-17 11:24:47 首次发布

本文链接：https://blog.csdn.net/luoj_616/article/details/126380794

版权

Kotlin 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

程序的逻辑控制
程序的执行语句主要分为三种：

顺序语句：一条接着一条顺序执行下去，程序代码默认就是顺序语句。

条件语句：if 和 when

循环语句：for循环和 while循环

条件语句
Kotlin 中的条件语句主要有两种实现方式：if 和 when。

if
Kotlin 编程语言流程控制语句通过程序设定一个或多个条件语句来设定：

if 额外功能：

if 有个返回值

在条件为 true 时执行指定程序代码

在条件为 false 时执行其他指定代码

fun main() {
    val number = 83
    val str = if (0 < number && number <= 59) {
        //0-59范围
        "$number 不及格"
    } else if (59 < number && number <= 75) {
        "$number 及格"
    } else if (75 < number && number <= 85) {
        "$number 良好"
    } else {
        "$number 优秀"
    }
    println(str)
}

使用区间 range 表达式

in x..y，in关键字用来检查某个值是否在指定区间x-y(包含y)之内。

！in 不在

使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y ：

实例



fun main(args: Array<String>) {
    val x = 5
    val y = 9
    if (x in 1..8) {
        println("x 在区间内")
    }
}

until 关键字
使用 until关键字创建一个左闭右开的区间。

实践

//使用until关键字创建一个左闭右开的区间。
//区间范围[3,8)

    for (number in 3 until 8){
        println(number)
    }

step 关键字
使用 step 关键字跳过一些元素。for-in循环每次执行循环时会在区间范围递增1，如Java中 for-i 的i++。

实践

//使用 step 关键字跳过一些元素。
//如Java中 for-i 的i = i+2。

    for (number in 3 until 8 step 2) {
        println(number)
    }

downTo 关键字
使用 downTo 关键字创建一个降序区间。

//使用 downTo 关键字创建一个降序区间。
//区间范围[8,3]

    for (number in 8 downTo 3) {
        println(number)
    }

When 表达式

允许你编写条件式，在某个条件满足时，执行对应的代码
只要代码包含else if分支，都建议改用when

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。

when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用，则忽略个别分支的值。

when 类似其他语言的 switch 操作符。

在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。

如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：

when (x) {
    1 -> print("x == 1")
    2 -> print("x == 2")
    3,4->print("x==3,4")
    else -> { // 注意这个块
        print("x 不是 1 ，也不是 2")
    }
}

我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：

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")
}

when 中使用 in 运算符来判断集合内是否包含某实例：



fun main(args: Array<String>) {
    val items = setOf("apple", "banana", "kiwi")
    when {
        "orange" in items -> println("juicy")
        "apple" in items -> println("apple is fine too")
    }
}

另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。注意：由于智能转换，你可以访问该类型的方法和属性而无需任何额外的检测。

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

For 循环

for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:

for (item in collection) print(item)

循环体可以是一个代码块:

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

fun main(args: Array<String>) {
    val items = listOf("apple", "banana", "kiwi")
    for (item in items) {
        println(item)
    }

    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }
}

返回和跳转

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

return。默认从最直接包围它的函数或者匿名函数返回。
break。终止最直接包围它的循环。
continue。继续下一次最直接包围它的循环。

在循环中 Kotlin 支持传统的 break 和 continue 操作符。

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

Kotlin学习笔记（1）：标签

标签的声明方式：标签名++"@"，如：abc@
标签的引用方式："@"++标签名，如：@abc

Kotlin中标签的含义和Java中的基本一致，都是为了方便跳转到指定位置，常和 break 和 continue 搭配使用。但是Kotlin中的标签还可以和 return 搭配使用，表示在标签处返回。

Break和Continue

举例如下：

fun main(args: Array<String>) {
    for (i in 1..4) {
        for (j in 1..4) {
            if (i == 2 && j == 2) {
                break
            }
            println("i = $i, j = $j")
        }
    }
}

以上代码表示中的 break 仅仅是跳出了内层循环，也就是当 i=2,j=2 时终止内层循环，然后 i 加 1 继续循环。打印结果如下：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 1, j = 4
i = 2, j = 1
i = 3, j = 1
i = 3, j = 2
i = 3, j = 3
i = 3, j = 4
i = 4, j = 1
i = 4, j = 2
i = 4, j = 3
i = 4, j = 4

如果想让 i=2,j=2 时直接跳出外层循环，就可以使用标签，代码如下：

fun main(args: Array<String>) {
    loop@ for (i in 1..4) {
        for (j in 1..4) {
            if (i == 2 && j == 2) {
                break@loop
            }
            println("i = $i, j = $j")
        }
    }
}

在外层循环处声明一个标签loop@，当需要 break 的时候，直接使用break@loop就可以跳出外层循环。运行结果如下：

i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 1, j = 4
i = 2, j = 1

上面的代码等价于如下Java代码：

    public static void main(String[] args) {
        loop: for (int i = 1; i <= 4; i++) {
            for (int j = 1; j <= 4; j++) {
                if (i == 2 && j == 2) {
                    break loop;
                }
                System.out.println("i = " + i + ", j = " + j);
            }
        }
    }

continue 标签的使用方式和 break 一样，不再赘述。

标签处返回

举例如下：

fun main(args: Array<String>) {
    val ints = intArrayOf(1, 2, 3, 0, 4, 5, 6)
    ints.forEach {
        if (it == 0) return
        print(it)
    }
}

上面代码中的 return 指的是从 main 函数中返回，因为 main 函数是最直接包围它的函数。所以运行结果为：

如果想要从 forEach 中的 lambda 表达式中返回，就需要使用标签了。代码如下，在 lambda 表达式的前面声明一个标签lit@，然后在 return 处使用标签，即return@lit。

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

运行结果为：

除了这种方式之外，还可以使用隐式标签。该标签与接受 lambda 表达式的函数同名，在上个例子中就是 forEach 。即：

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

如果不使用标签，还可以使用匿名函数替代 lambda 表达式实现上述功能，代码如下。匿名函数内部的 return 语句将从该匿名函数自身返回，但使用这种方式不如使用 lambda 表达式代码清晰简洁。

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

参考资料：http://kotlinlang.org/docs/reference/returns.html

luoj_616

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
koltin(四) 逻辑控制 if when 循环

kotlin if when for
复制链接

扫一扫

专栏目录