Kotlin语法

java和Kotlin把兄弟，但是如果不了解Kotlin的语法而阅读它的源码还是有一点困难。所以收集整理一下Kotlin的语法，对小白来说可以方便的理解。

fun main(args: Arrag<String>){// 函数声明 程序入口 函数接收的参数名 参数的数据类型（字符串数组）
    println("Hello World")
}

var a : Int // 声明一个int类型的可变变量a
val b : Int // 声明一个int类型的不可变变量b
var c = 1
var d ：Int
d = 10
// 数值类型变量
var a : Byte = 1
var b : Short = 1
var c : Int = 1
var d : Long = 1L
var e : Float = 1f
var f Double = 1.0
// 布尔类型变量
var a : Boolean = true
var b = true
// 字符类型变量
var a : Char = 'a'
var b = 'b'
// 字符串类型变量
var a : String = "Hello World !"
var b = "Hello World !"
// 数组类型变量表达方式一
var int_array : IntArray = intArrayOf(1,2,3)
var boolean_array : BooleanArray = booleanArrayOf(true,true,false)
var char_array ：CharArray = charArrayOf('a','b','c')
// 数组类型变量表达方式二
var int_array1 : Array<Int> = arrayOf(1,2,3)
var boolean_array1 : Array<Boolean> = arrayOf(true,false,true)
var char_array1 : Array<Char> = arrayOf('a','b','c')
var string_array : Array<String> = arrayOf("Hello","World","!")

// 算术运算符，自增、赋值的先后顺序
%  取模（即余数）     8%3                  2
.. 范围              a=1;b=a..2           a=1;b=1..2
++ 自增（前）         a=1;b=++a            a=1;b=2(a赋值给a，再执行a+a赋值给b)
++ 自增（后）        a=1;b=a++             a=2;b=1(a赋值给b,再执行++赋值给a)
-- 自减(前)         a=1;b=--a             a=1;b=0
-- 自减(后)         a=1;b=a--             a=0;b=1
// 除法运算时，如果除数和被除数都是整数，结果也会是整数，如3/2=1，因为小数被忽略了
// 当除数和被除数中有小数时，结果会是一个小数，如1.0/2=0.5
// 综上，1500/1000*1000 = 1000
var a : Int = 1
var b : Int = 2
var c : Int = a + b++
// 因为++写在了b的后面，属于先运算再自增，所以计算"a + b"时，b的值仍然还是2，所以c=3，
// 而b在运算完后执行自增（+1），b=3

// 赋值运算符
+=  加等于 a=6;b=5;a+=b          a=11;b=5
-=  减等于 a=6;b=5;a-=b          a=1;b=5
+=  乘等于 a=6;b=5;a*=b          a=30;b=5
/=  除等于 a=6;b=5;a/=b          a=1;b=5
%=  模等于 a=6;b=5;a%=b          a=1;b=5

// 比较运算符
==
!=
<
>
<=
>=
// 逻辑运算符
!    非  
&&   短路与  true&&true   true       一假都加
             true&&false  false
||   短路或  true&&false   true       一真都真

// 字符串
var str : String = "Hello World!"
var str1 = "Hello World!"
println(str.length)// 获取字符串长度
println(str.get(4))// 获取第五个元素
println(str[4])// 通过索引方式访问某个字符，角标从0开始，结果为“o”
println(str.first())// 获取第一个元素
println(str.last())// 获取最后一个元素
println(str.indexOf('o'))// 获取第一次出现o的角标
println(str.lastIndexOf('o'))// 获取最后一次出现o时的角标
// 截取字符串
println(str.substring(3))// 从角标3开始，到最后。截取
println(str.substring(3,7))// 截取3到6（注意不包含7）
println(str.substring(IntRange(3,7)))// 截取3到7
println(str.subSequence(3,7))// 截取3到6
println(str.subSequence(IntRange(3,7)))// 截取3到7
// 替换字符串
println(str.replace("World","Kotlin"))// 所有的World替换成Kotlin
println(str.replaceFirst("World", "Kotlin"))// 替换第一个World为Kotlin
println(str.replaceBefore("!", "Kotlin"))// 把！之前的替换为Kotlin
println(str.replaceAfer("Hello", "kotlin！"))// 把Hello之后的替换为Kotlin！
// 分割字符串
var str = "Hello.kotlin/world"
var split = str.split(".", "/")// [Hello,kotlin,world]
// 字符串去空格
str.trim()// 除去字符串前面的空格
str.trimEnd()// 除去字符串后面的字符

for (c in str){// for循环迭代字符串，循环输出str，结果为“Hello World！”
    print(c)
}

// 模板表达式
var a = 1
var s1 = "a is ${a}"
var s2 = "a is $a"// 他俩的结果是一样的
// 同样可以套用方法
fun helloWorld() : String{// String该方法的返回值类型
    return "Hello World"
}
println("${helloWorld()}")
// 可以支持替换
var a = "a is 1"
var s3 = "${a.replace("is", "was")}"// a was 1

// when条件语句
var week : Int = 3
when(week){
    1 -> println("星期一")// 也可以是：1,2,3 ->
    2 -> println("星期二")// 也可以是：a > b ->pringln("..")
    3 -> println("星期三")
    4 -> println("星期四")
    5 -> println("星期五")
    6 -> println("星期六")
    7 -> println("星期日")
    else ->{
        println("输入的数字不正确......")
    }
}

//while循环语句
var n : Int = 5
while (n > 0){// 循环到一
    println("n="+n)
    n--
}
do{// do...while和while的区别是do...while至少循环一次
 执行语句
}whlie(循环条件)

// for循环
for(i in 0..3){// 取值区间0~3
    println("i => $i \t")
}
// foreach循环，为遍历集合、数组提供了极大的便利
var arr : IntArray = intArrayOf(1,2,3,4,5)
arr.forEach(){
    println(it.toString() + "\t")// it值arr中的元素对象
}
// 带角标的forEach
var arr : IntArray = intArrayOf(1,2,3,4,5)
arr.forEach(){index,it ->
    println("角标=$index 元素=${it} ")// it值arr中的元素对象
}

// 跳转语句
break// 跳出循环
continue// 结束本次循环，执行下次循环

// 区间
1 in 1 until 4// 123
1 in 1..4 step2// 1 3,步长为2

// 数组array
var int_array : IntArray = intArrayOf(1,2,3)// 定义形式1
var int_array : Array<Int> = arrayOf(1,2,3)// 定义形式2
int_arr[0]// 获取第1个元素
// 数组遍历
var int_arr : IntArray
int_arr = intArrayOf(1,2,3)
for(i in int_arr){
    println(i)
}
// 执行结果
1
2
3
// 取数组的最大值
fun main(args : Array<Sring>){
    var arr : IntArrayOf(1,2,3,4)
    var max : Int = 0
    max = arr[0]// 假设数组中第一个元素为最大值
    for(i in arr){
        if(i > max){
            max = i
        }
    }
    println("max="+max)
}
// 输出结果：4

// 数组元素修改
newArr[0] = 10// 把第一个元素设置为10
newArr.set(3,16)// 把第四个元素设置为16
newArr.forEachIndexed{index, i ->
    println("角标=$index 元素=$i")
}

// 查找数组元素的角标
var newArr : IntArray = intArrayOf(6,4,3,4,9)
newArr.indexOf(4)// 返回结果1，这里是第一次出现
var index = newArr.indexOfFirst(// newArr/lastIndexOf(4)是找最后一个元素为4的角标
    it = 4
)
println("第一个元素为4的角标为"+index)// 结果为1

// 变量类型转换
// 按转换方式可以分为：智能类型转换和强制类型转换

// 类型检查
var a:Boolean = someObj is Class// is操作符
var b:Boolean = soneObj !is Class// !is反向操作符。作用是提前检测对象是否是特定类
// 实例
var a:Any = "hello"// Any表示任意类型，类似于Object
var result1 = a is String// a 是字符串
var result2 = a !is String// a不是字符串
println(result1)
println(result2)
// 输出结果
true
false

// 智能类型转换
var a : Any = "hello"
if(a is String){
    println("a is String")
    println("字符串长度="+a.length)
} else if(a !is Int){// a不是Int，这显然也是真的，这个问题有待商榷
    println("a !is Int)
}

// 强制类型转换 as
var a = "1"
var b : String = a as String// 这就很蛋疼，它本来就是字符串。。

var a = 1
var b ：String = a as String// 将a强转为String，会崩，因为a是Integer型，这个as就比较鸡肋

var a = 1
var b : String? = a ?as String
println(b?.length)// 输出结果为null，加？是一种安全的强转，一旦不行就返回null

// 空值处理
var name : String// 这里值不可空
var age : Int?// 这里值可空，在使用可空变量时，如果不知道初始值，最好赋值个null，否则可能会报未实例化的异常

// 安全调用符 ?.就是说不为null的时候才调用，否则返回null
var name : String? = null
println(name?.lengtn)// 返回null

// Elvis操作符 ?: 就是值为空时返回一个给定的默认值
var name : Sring? = null
println(name?.length ?: "jun")// 执行结果：jun

// 非空断言
var name : String? = null
println(name!!.length)// 会抛异常，name本来可空的，也确实是空的，加了个非空断言，就变成不可空的，报空指针

完结撒花