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