Kotlin学习笔记(二)循环,跳转

时间:2022-11-09 18:58:25

提示:本文为作者阅读Kotlin中文站学习笔记,建议读者移步Kotlin中文站完整学习。

源文件通常以包声明开头,源文件所有内容都包含在声明的包内,如果没有声明包,文件内容属于无声明的默认包。当我们创建一个Kotlin文件时,Android studio会帮我们在文件顶部自动声明包。

package com.gyg.kolin

Kotlin会默认导入一些包到文件中,除了默认导入的包,开发者也需要导入自己的包,可以单独导入包下的某一个内容,也可以导入包下的所有内容。当命名冲突时,可以通过as关键字在本地重命名来消除歧义。

import foo.Bar//导入foo包下的Bar
import foo.*//导入foo包下的所有内容
import foo.Bar as Bar2//导入foo包下的额Bar,并且本地重命名为Bar2

控制流

if表达式

在Kotlin中,if是一个表达式,它可以返回一个值。

val a:Int=23
val b:Int=46
val max:Int
max=if(a>b) a else b//if作为一个表达式,当a>b时返回值a,否则返回值b

if的分支也可以是一个代码块,最后的表达式为该块的值

val a:Int=23
val b:Int=46
val max:Int
max=if(a>b){
print("max="+a)
a
}else{
print("max="+b)
b
}

注意:如果if作为一个表达式使用,除非编译器能够检测出所有的可能情况都已经覆盖了,否则必须有else分支。

我们也可以像Java中一样,把if作为一个语句使用

val a:Int=23
val b:Int=46
val max:Int
if(a>b){
max=a
}else{
max=b
}

when表达式

when表达式,与Java中的switch语句类似。when 将它的参数和所有的分支条件顺序比较,直到某个分支满足条件。它可以被当作表达式使用, 符合条件的分支的值就是整个表达式的值。(像 if 一样,每一个分支可以是一个代码块,它的值是块中最后的表达式的值。)例如:

val a: Int = 3
val b: Int = 5
var max: Int
max = when (a > b) {
true -> {
print("max=a")
a
}
false -> {
print("max=b")
b
}
else -> {
print("a=b")
a
}
}

也可以当做语句使用, 忽略个别分支的值。

val a:Int=3
val b:Int=5
var max:Int
when(a>b){
true->{
print("max=a")
max=a
}
false->{
print("max=b")
max=b
}
else->{
print("a=b")
max=a
}
}

如果其他分支都不满足条件将会求值 else 分支。 如果 when 作为一个表达式使用,则必须有 else 分支, 除非编译器能够检测出所有的可能情况都已经覆盖了。

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

var x:Int=0
when(x){
0,1-> print("x==1或x==2")
else-> print("otherwise")
}

我们可以用任意表达式(而不只是常量)作为分支条件

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

我们也可以检测一个值在(in)或者不在(!in)一个区间或者集合中:

val x:Int=5
val values:IntArray= intArrayOf(0,5,7,9)
when(x){
in 0..10->{//区间
print("x is in 0..10")
}
in values->{//集合
print("x is in values")
}
}

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

fun getType(value:Any):Unit{
when(value){
is String-> print("value is a String type")
is Int-> print("value is Int type")
else-> print("value is not a String type or Int type")
}
}

如果不提供参数,所有的分支条件都是简单的布尔表达式,而当一个分支的条件为真时则执行该分支:

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

For循环

for循环可以对任何提供迭代器(iterator)的对象进行遍历,即这个对象:

  • 有一个成员函数或者扩展函数iterator(),它的返回类型

    • 有一个成员函数或扩展函数next(),返回这个对象的成员元素。并且
    • 有一个成员函数或者扩展函数hasNext()返回Boolean。

    这三个函数都要标记为operator。

val str:String="Hello world"
for (item in str) print(item)

对数组的 for 循环会被编译为并不创建迭代器的基于索引的循环。
如果你想要通过索引遍历一个数组或者一个 list,你可以这么做:

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

注意这种“在区间上遍历”会编译成优化的实现而不会创建额外对象。
或者你可以用库函数 withIndex:

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

While循环

我们可以以在Java中的相同姿势来在Kotlin中使用while循环和do..while循环。

while (x > 0) {
x--
}

do {
val y = retrieveData()
} while (y != null) // y 在此处可见

返回和跳转

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

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

这些表达式的类型都是Nothing类型。
所有这些表达式可以作为包含它的更大表达式的一部分:

val name=person.name?:return

Break,Continue标签

Kotlin中,我们可以用标签来标记一个表达式,标签的格式为:标签字符后跟@符号,例如:abc@,foreach@等等。要为一个表达式加标签,我们只要在其前加标签即可。

abc@ for (item in str) print(item)

我们可以用标签来限制break和continue表达式:

outer@for (i in 0..10){
innrer@for (j in 0..10){
if (i==3&&j==3)continue@outer
if (i==5&&j==5) break@outer
}
}

标签限制的break跳转到更好位于该标签指定的循环后面的执行点,continue继续标签指定的循环的下一次循环。

标签处返回

Kotlin中,return语句是从最直接包含它的fun标记的函数中返回,例如下面这样:

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

ruturn 直接从foo()函数中返回,如果我们要从lambda表达式中返回,必须给它加标签并用以限制return表达式:

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

这样,return就会从lambda函数中返回。或者更方便的,我们可以使用隐式标签,它与接受该lambda表达式的函数同名:

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

或者,我们用匿名函数来代替lambda表达式,匿名函数里的return表达式,将直接从该匿名函数中返回。

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

当要返回一个值的时候,解析器优先选用标签限制的 return,即

return@a 1

意为“从标签 @a 返回 1”,而不是“返回一个标签标注的表达式 (@a 1)”。