题外话，Android Studio里面的var变量有个下划线，看着不爽的话可以再idea工具设置不显示
图片.png
if表达式
一个 if 语句包含一个布尔表达式和一条或多条语句。
// 传统用法 和java一样，有区别的就是kt里面能作为表达式用，真的是骚
var max = a
if (a < b) max = b
// 使用 else
var max: Int
if (a > b) {
max = a
} else {
max = b
}
// 作为表达式 因为kt里面没有三元运算符所以下面这个就可以看做是java里面的三元运算符一样
val max = if (a > b) a else b
//当然还可以这么玩 不过好像没有什么使用场景
val max = if (a > b) {
print("Choose a")
a
} else {
print("Choose b")
b
}
return max
使用区间
使用 in 运算符来检测某个数字是否在指定区间内，区间格式为 x..y ：
var a = 5
if (a in 1..10) {
println("$a is in range 1 to 10")
}
When 表达式
when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。这货居然是switch，kt的码农是不是不懂英文，O(∩_∩)O哈哈~
when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。对于符合条件的（相当于case）需要使用->符合
when 类似其他语言的 switch 操作符。其最简单的形式如下：
var x = 10
when (x) {
1 -> print("x == 1")
2 -> print("x == 2")
else -> { // 注意这个块
print("x 不是 1 ，也不是 2")
}
}
在 when 中，else 同 switch 的 default。如果其他分支都不满足条件将会求值 else 分支。
如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔：
when (x) {
0, 1 -> print("x == 0 or x == 1") //x为0或者1
else -> print("otherwise")
}
fuck哟，用了kt之后三观尽毁啊
当做表达式使用：
var gender = "男"
var value:Int
value = when(gender) {
"女" -> {
0
}
else -> 1
}
print(value)
我们也可以检测一个值在（in）或者不在（!in）一个区间或者集合中：
var x = 15
when (x) {
in 1..10 -> println("x is in the range")
!in 10..20 -> println("x is outside the range")
else -> {
x = 100
x++
println(x)
println("none of the above")
}
}
如果需要在分支里面写语句段需要加{}括号如上else语句
另一种可能性是检测一个值是（is）或者不是（!is）一个特定类型的值。注意： 由于智能转换，你可以访问该类型的方法和属性而无需 任何额外的检测。智能转换这个技能是真的强
fun checkType(a: Any?) { //类型后面加?表示可以为null 参数，返回值均是这样
when(a) {
is String -> {
println("是字符串")
println("字符长度${a.length}")//智能转换，无需再判空
}
is Int -> println(a + 1)
else -> println("其他类型")
}
}
fun isString(string: String) = when(string) {
is String -> true
else -> false
}
函数还能这么写就问你强不强
when 也可以用来取代 if-else if链。 如果不提供参数，所有的分支条件都是简单的布尔表达式，而当一个分支的条件为真时则执行该分支：
when {
x.isOdd() -> print("x is odd")
x.isEven() -> print("x is even")
else -> print("x is funny")
}
when 中使用 in 运算符来判断集合内是否包含某实例：
val items = setOf("apple", "banana", "kiwi")
when {
"orange" in items -> println("juicy")
"apple" in items -> println("apple is fine too")
}
只要是布尔类型均可以使用只要有一个分支为true下面的就不会再执行，个人觉得这种用法并不好用，优选if else结构
Kotlin 循环控制
For 循环
for 循环可以对任何提供迭代器（iterator）的对象进行遍历，语法如下:
for (item in collection) print(item)
val strings = arrayOf("a", "b", "c")
for (string in strings) {
println(string)
}
如上所述，for 可以循环遍历任何提供了迭代器的对象。
如果你想要通过索引遍历一个数组或者一个 list，你可以这么做：
for (i in strings.indices) {
println(strings[i])
}
注意这种"在区间上遍历"会编译成优化的实现而不会创建额外对象。
或者你可以用库函数 withIndex：
for ((index, value) in array.withIndex()) {
println("the element at $index is $value")
}
for循环示例：
for (k in 1..4) {//正序
println(k)
}
for (k in 4 downTo 1) {//倒序
println(k)
}
for (k in 1..4 step 2) {//设置步长
println(k)
}
for (k in 4 downTo 1 step 2) {//倒序设置步长
println(k)
}
for (l in 1 until 4) {//不包括4
print(l)
}
while 与 do...while 循环
while是最基本的循环，它的结构为：
while( 布尔表达式 ) {
//循环内容
}
do…while 循环 对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
和java是完全一样的就不多讲了
范例：
var x = 3
while (x>0) {
println(x--)
}
println("--------------do while------------")
var y = 3
do {
println(y--)
}while (y>0)
返回和跳转
Kotlin 有三种结构化跳转表达式：
return。默认从最直接包围它的函数或者匿名函数返回。
break。终止最直接包围它的循环。
continue。继续下一次最直接包围它的循环。
在循环中 Kotlin 支持传统的 break 和 continue 操作符。这些也是和java一样的不再赘述
举个栗子：
for (i in 1..10) {
if (i == 3) continue // i 为 3 时跳过当前循环，继续下一次循环
println(i)
if (i == 5) break // i 为 5 时 跳出循环
}
虽然是一样的，kt还是搞了点新东西出来
Break 和 Continue 标签
在 Kotlin 中任何表达式都可以用标签（label）来标记。 标签的格式为标识符后跟 @ 符号，例如：abc@、fooBar@都是有效的标签。 要为一个表达式加标签，我们只要在其前加标签即可。其实也和java一样只不过java不用@符合用：符号
a@ for (i in 1..3) {
for (j in 1..3) {
if (j == 2) continue//跳过内层的本次循环，执行下一次循环
if (j == 2) break //跳出内层循环
if (j == 2) continue@a//跳过外层的本次循环，执行下一次循环
if (j == 2) break@a //跳出外层循环
println("$i,$j")
}
}
标签处返回
Kotlin 有函数字面量、局部函数和对象表达式。因此 Kotlin 的函数可以被嵌套。 标签限制的 return 允许我们从外层函数返回。 最重要的一个用途就是从 lambda 表达式中返回。回想一下我们这么写的时候：
fun foo() {
var ints = arrayOf(1,2,3)
ints.forEach {
if (it == 2) return
println(it)
}
println("行尾")
}
这个 return 表达式从最直接包围它的函数即 foo 中返回。 （注意，这种非局部的返回只支持传给内联函数的 lambda 表达式。） 如果我们需要从 lambda 表达式中返回，我们必须给它加标签并用以限制 return。
fun foo() {
ints.forEach lit@ {
if (it == 0) return@lit
print(it)
}
}
现在，它只会从 lambda 表达式中返回。通常情况下使用隐式标签更方便。 该标签与接受该 lambda 的函数同名。
fun foo() {
var ints = arrayOf(1,2,3)
ints.forEach {
if (it == 1) return@forEach
println(it)
}
println("行尾")
}
ps:但是这种标签返回和continue的效果一样啊，并没有不再执行后续。
或者，我们用一个匿名函数替代 lambda 表达式。 匿名函数内部的 return 语句将从该匿名函数自身返回
fun foo() {
ints.forEach(fun(value: Int) {
if (value == 0) return
print(value)
})
}
当要返一个回值的时候，解析器优先选用标签限制的 return，即
return@a 1
意为"从标签 @a 返回 1"，而不是"返回一个标签标注的表达式 (@a 1)"。
网友评论