kotlin 基础

类型

数字类型

• Double 64 位
• Float 32 位
• Long 64 位
• Int 32 位
• Short 16 位
• Byte 8 位

布尔类型

Kotlin 使用 Boolean 类表示布尔类型，他有两个值： true 和 false

String 字符串类型

Kotlin 中用 String 类型表示，同样，String 是 final 的，不可被继承。

变量

变量： 以关键字开始，然后是变量名称，最后加上变量类型（也可以不加，会自动推断）

val a1: Int = 32
val question = "the question is xxx"

如果变量没有初始化，需要显式的指定它的类型

val answer:Int 
answer = 23

可变变量，不可变量

• val : 不可变引用，使用的 val 声明的变量不能在初始化之后再次赋值，它对应的是 Java 的 final 变量
• var : 可变引用， 这种变量的值可以被改变，这种声明对应的是普通的 Java 变量。

函数

**函数定义: **使用关键字 fun 定义, 参数格式为 参数名称： 参数类型。如下：

fun max(a: Int, b: Int) : Int {
    return if(a>b) a else b
}

fun sum(a: Int，b: Int) = a + b     // 表达式作为函数体，返回类型自动推断
public fun sum(a:Int ,b: Int) : Int = a + b     // public 方法则必须明确写出返回类型

如果函数没有返回值，则返回类型为 Unit , 与 Java 中的 void 是相似的。

可变长参数函数: 函数的变长参数用 vararg 关键字进行标识。

fun sum(vararg args: Int) : Int {
	var result = 0
    for(vt in args) {
        result += vt
    }
    return result
}
fun main(args: Array<String>) {
    println(sum(1,2,3,4))
}

字符串模板

$ 标识一个变量名 或 变量值

$varName 表示变量值

${varName.fun()} 表示变量的方法返回值

val name = "tom"
println("hello,$name !")

val res = "${name.replace("m","n")}"

类型检测及自动类型转换

使用 is 运算符检测一个表达式是否是某类型的一个实例(类似 Java 中的 instanceof 关键字)

fun getStringLength(obj: Any) : Int? {
    if(obj is String) {
        // 做过类型判断后， obj 会被系统自动转换成 String 类型
        return obj.length
    }
}

Kotlin 中 null 值处理方式

在 kotlin 中，类型系统将可空类型和不可类型进行了区分，比如：

String     =>  不可空类型
String？   =>  可空类型 
// 如果将不可控类型赋值为 null 将编译不通过。
var len : Int? = null
var str: String? = null
var str1: String = null     //编译不通过

可空类型的调用，需要先做检查，否则将出现空指针异常。

fun testNull(str: String?): String {
    if (str != null && str.length != 0) {
        return str.toUpperCase()
    }else {
        return "NULL"
    }
}

其实，Kotlin 为我们提供了更安全的调用方式，使用 ?. 进行调用

var str: String? = null
var length = str?.length
println(length) 

var len = str?.length ?: -1     // 如果 str 为 null ,则返回 -1, 否则返回 str.length
println(len)

如果 str 为 空引用，则直接返回 null, 否则返回 str.length

数值的比较

判断两个数值是否相等使用 == ， 判断两个数值在内存总的地址是否相等，使用 ===

fun testEquals() {
    var num: Int = 128
    val numBox: Int? = num
    var result: Boolean = num == numBox      // 比较数值是否相等
    println("num == numBox => $result")      // true ,两个数值是相等的
    var addr: Boolean  = num === numBox      // 比较地址是否相等 
    println("num === numBox => $" )          // false, Int 类型的变量，大于 127，其内存地址不同 
    
    var num1: Int = 127
    var numBox1: Int = num1
    var addr1 = num1 === numBox1
    println("num1 === numBox1 => $addr1")     // num1 === numBox1 => true
}

总结：Int 类型的变量，大于 127 其内存地址不相同，反之则相同。这是 kotlin 的缓存策略导致的，而缓存的范围是 -128 - 127 之间。

数组

数组创建

创建数组的方式：

1. 使用 arrayOf 函数定义可以存储任意值的数组

   // 创建包含指定元素的数组,相当于 Java 数组的静态初始化，int[] arr = {1,2,3,4}
       var strArray = arrayOf("Java","Kotlin")
       var intArr = arrayOf(1,2,3)
   

2. 使用 arrayOfNulls() 函数定义数组

   // 创建指定长度，元素为 null 的数组,相当于 Java 数组的动态初始化
   var nullStringArr  = arrayOfNulls<String>(5)
   var nullIntArr = arrayOfNulls<Int>(5)
   nullStringArr.set(0,"apple")
   nullStringArr.set(3,"google")
   for (i in nullStringArr) {
   	println(i)
   }
   

   输出结果：

   apple
   null
   null
   google
   null
   

3. 使用 Array 类的构造器定义数组，其中第二个参数是指初始化每一个数组元素的值

   var arr = Array(3, { i -> (i * i).toString() })
   for (s in arr) {
       println(s)
   }
   

   输出结果：

   0
   1
   4
   

数组遍历

var arr = Array(3, { i -> (i * i).toString() })
for (s in arr) {
	println(s)
}

遍历数组下标

var arr = Array(3, { i -> (i * i).toString() })
for (index in arr.indices) {
	println(index)
}

元素获取

• 下标获取
• get()
• elementAt(Int)
• first()
• last()
• getOrNull()

fun main(args: Array<String>) {
    var intArr = arrayOf(1, 2, 3)
    println("通过下标获取： 第 0 个元素：${intArr[0]}")
    println("通过 get() 获取，第 1 个元素:  ${intArr.get(1)}")
    println("通过 getOrNull() 获取，第 3 个元素: ${intArr.getOrNull(3)} ")
    println("通过 elementAt() 获取，第 2 个元素：${intArr.elementAt(2)} ")
    println("通过 first 获取最前面一个元素： ${intArr.first()}")
    println("通过 last 获取最后面一个元素：  ${intArr.last()}")
}

输出结果：

通过下标获取： 第 0 个元素：1
通过 get() 获取，第 1 个元素:  2
通过 getOrNull() 获取，第 3 个元素: null 
通过 elementAt() 获取，第 2 个元素：3 
通过 first 获取最前面一个元素： 1
通过 last 获取最后面一个元素：  3

是否包含元素 contains()

fun main(args: Array<String>) {
    var intArr = arrayOf(1, 2, 3)
    println("intArr 是否包含元素 1 === ${intArr.contains(1)}")
}

输出结果：

intArr 是否包含元素 1 === true

获取数组长度： size 属性，count() 方法

fun main(args: Array<String>) {
    var intArr = arrayOf(1, 2, 3)
    println("size 属性获取数组长度： ${intArr.size}" )
    println("count() 方法获取数组长度： ${intArr.count()}")
}

输出结果：

size 属性获取数组长度： 3
count() 方法获取数组长度： 3