Kotlin 学习--语言基础

标签（空格分隔）： kotlin

申明变量

var和val
var:变量申明,可变，表示这个变量可以多次赋值
val:变量声明,不可变，类似java中final定义的变量，只读，当被赋值之后就不能再赋值

fun testVariable(){
    var a = 1 //var 定义的变量是可以多次赋值的
    a = 3 //重新赋值
    println(a)
    var x = 5
    x+=1
    println("x = $x")//串模板 串可以包含模板表达式，即：可计算的代码片段，其结果链接到串中。模板表达式以美元符号（$）开始，和简单的名字构成：

    val l = "kotlin" //val定义的是一旦被赋值之后就不能再赋值，类似java的final
//    l = "string" //编译器报错:val cannot be reassigned
    println(l)
    val j:Int = 1 //立即赋值
    val i = 1 //自动推断出类型
    val u : Int //没有赋值，得先确认类型
    u = 3
    println("j:$j===i:$i===u:$u")
}

编译结果

3
x = 6
kotlin
j:1===i:1===u:3

控制语句

1、if语句

在kotlin中的if语句和java中的还是有很大的区别，在kotlin中更加灵活，不当可以实现java的写法外，还能实现表达式（三元运算符），以及作为一个块的运用。

1.1与java一样的写法

var flag = 3
if (tag == flag){
    println("$flag == $tag--->true")
}else{
    println("$flag == $tag--->false")
}

1.2 kotlin中的三元运算符

其实在kotlin中并没有存在三元运算符(condiution?then:else)这种操作的。只是因为if语句的特性（if表达式会返回一个值），所以不用三元运算符，或者说可以当做三元运算符

var flag = 3
//在kotlin中直接用if...else...代替
var num = if(flag > 3) 3 else 5
println("num--->$num")

num--->5

由上可知，kotlin的if可以作为一个表达式并返回一个值

1.3作为一个块，并且最后一句为返回的值

var flag = 3
var numA = if (flag <3){
    flag = 10
    println("numA < 3 is true")
    flag
}else if (flag == 3){
    flag = 20
    println("numA = 3 is true")
    flag
}else{
    flag = 30
    println("numA > 3 is true")
    flag
}
println("numA ---> $numA")

numA = 3 is true
numA ---> 20

2、when语句

when 将它的参数和所有的分支条件顺序比较，直到某个分支满足条件。
when 既可以被当做表达式使用也可以被当做语句使用。如果它被当做表达式，符合条件的分支的值就是整个表达式的值，如果当做语句使用， 则忽略个别分支的值。
when不仅可以替代Java的switch，还比之强大许多，让我们往下看：

2.1 看先简单的替代switch

var tag = 3
when(tag){
    1 -> print(1)
    2 -> print(2)
    else -> println("else")//这里的else就是switch中的default
}

else

2.2 如果很多分支需要用相同的方式处理，则可以把多个分支条件放在一起，用逗号分隔(相当于把switch中的bread去掉)：

var tag = 3
when(tag){
    1 -> print(1)
    2 -> print(2)
    3,4 -> println("tag等于3或者等于4")
    else -> println("else")
}

tag等于3或者等于4

2.3 in运算符

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

var tag = 6
when(tag){
    1 -> print(1)
    2 -> print(2)
    3,4 -> println("tag等于3或者等于4")
    in 5..10-> println("tag在5到10之中")
    !in 11..20-> println("tag不在11到20之中")
    else -> println("else")//这里的else就是switch中的default
}

tag在5到10之中

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

var item = setOf("flutter", "kotlin", "java")
when {
    "android" in item -> println("android is contains of item")
    "kotlin" in item -> println("kotlin is contains of item")
}

kotlin is contains of item

***2.4 检查值是否为指定类型的值--is

var tag = 2
when(tag){
    is Int -> println("$tag is a int")
}

2 is a int

2.5 when中不一定限定常量，也可以是任意表达式

var tag = 8
when(tag>1){
    true -> println("tag大于1")
    false-> println("tag小于1")
    else-> println("tag等于1")
}

tag大于1

2.6 不使用表达式的when语句

像上面if做为块的实例，其实可以改成when,when也可以被当做表达式

var numA = when {
    flag < 3 -> {
        flag = 10
        println("numA < 3 is true")
        flag
    }
    flag == 3 -> {
        flag = 20
        println("numA = 3 is true")
        flag
    }
    else -> {
        flag = 30
        println("numA > 3 is true")
        flag
    }
}
println("numA ---> $numA")

numA ---> 20

3、for语句

• Kotlin废除了Java中的for(初始值;条件；增减步长)这个规则。但是Kotlin中对于for循环语句新增了其他的规则，来满足刚提到的规则。
• for循环提供迭代器用来遍历任何东西
• for循环数组被编译为一个基于索引的循环，它不会创建一个迭代器对象

3.1 新增规则来满足Java中的for(初始值;条件；增减步长)规则

3.1.1 until关键字 until[m,n)即大于等于m，小于n

for (i in 0 until 5){
    print("递增--->$i")
}

递增--->0递增--->1递增--->2递增--->3递增--->4

3.1.2 downTo关键字 downTo[x,y] 即小于等于x，大于等于y

for (i in 8 downTo 6){
    print("递减--->$i")
}

递减--->8递减--->7递减--->6

3.1.3 符号（' .. '） 表示递增的循环的另外一种操作，范围大于等于m,小于等于n，与until关键字对比之下，比较简明，范围不一样

for (i in 1 .. 5){
    print("..递增--->$i")
}

..递增--->1..递增--->2..递增--->3..递增--->4..递增--->5

3.1.4 设置步长 step

for (i in 3 until 12 step 3){
    print("i >>>$i \t")
}
    
i >>>3  i >>>6  i >>>9

3.2 迭代

3.2.1 遍历字符串

for (i in "abcefg"){
    print("i => $i \t")
}

i => a  i => b  i => c  i => e  i => f  i => g

3.2.2 遍历数组

var arrayList = arrayOf(1,2,3,4,5)
for (i in arrayList){
    print("i => $i \t")
}

i => 1  i => 2  i => 3  i => 4  i => 5

3.2.3 使用数组的indices属性遍历

var arrayListIndices = arrayOf(10,20,30,40,50)
for (i in arrayListIndices.indices){
    println("arrayListIndices[$i]--->"+arrayListIndices[i])
}

arrayListIndices[0]--->10
arrayListIndices[1]--->20
arrayListIndices[2]--->30
arrayListIndices[3]--->40
arrayListIndices[4]--->50

3.2.4 使用数组的withIndex()方法遍历

var arrayListWithIndex = arrayOf(10,20,30,40,50)
for ((index,value) in arrayListWithIndex.withIndex()){
    println("index-->$index \t value-->$value")
}

index-->0    value-->10
index-->1    value-->20
index-->2    value-->30
index-->3    value-->40
index-->4    value-->50

3.2.5 使用列表或数组的扩展函数遍历

• 数组或列表有一个成员或扩展函数iterator()实现了Iterator<T>接口，且该接口提供了next()与hasNext()两个成员或扩展函数
• 其一般和while循环一起使用

var arrayList = arrayOf(1,2,3,4,5)
val iterator = arrayList.iterator()
while (iterator.hasNext()){
    println(iterator.next())
}