//list創(chuàng)建和元素獲取
//創(chuàng)建list，但是是不可變的
val list = listOf("Jason", "jack", "jonse")
// println(list[3])//報異常
//getorElse是一個安全索引取值函數，它需要兩個參數，第一個是索引值，第二個是能提供默認值的lambda表達式，如果索引值不存在，可用來代替異常
println(list.getOrElse(3) {
"unknown"})
//另一個安全索引取值函數，它返回null結果，而不是拋出異常，因此適用于空安全運算符
println(list.getOrNull(3)?:"unknown")
-
mutator函數
能修改可變列表的函數有一個統(tǒng)一的名字：mutator函數
添加元素運算符 += 與刪除元素運算符 -=
//可變列表
val mutableListOf = mutableListOf("Jason", "jack", "jonse")
// mutableListOf.add("jinzong")
// mutableListOf.remove("jonse")
// println(mutableListOf)
//List支持使用toList和toMutableList函數動態(tài)實現只讀列表和可變列表的相互轉換
val toMutableList = list.toMutableList()
val toList = mutableListOf.toList()
//mutator函數
//能修改可變列表的函數有個統(tǒng)一的名字，mutator函數，例如上面的add，remove
//添加元素運算符+=
//刪除元素運算符-=
//基于lambda表達式指定的條件刪除元素
mutableListOf += "jinzong"
mutableListOf -= "jonse"
println(mutableListOf)
//集合遍歷
for (s in list) { //這個直接敲list.就可以找到for
println(s)
}
//與上面一樣的意思
list.forEach {
println(it)
}
//帶坐標
list.forEachIndexed { index, s ->
println("$index $s")
}
//解構語法過濾元素
//通過_符號過濾不想要的元素,這是之前的解構函數，如果我們不想給第二個元素賦值，直接使用_就行
val (a,b,c)= list
//過濾,相當于不給第二個元素賦值
val (a2,_,c2)= list
//set創(chuàng)建和元素的獲取與list，區(qū)別和java的是一樣的，list是有序且可以重復，set無序并且元素不能重復
val set = setOf("jack", "jacky", "jonse")
val elementAt = set.elementAt(2)//讀取集合中的元素
// set.elementAtOrNull(2) 與list一樣
// set.elementAtOrElse(2){"unknown"} //與list一樣
println(elementAt)
//語法和list是一樣的
val mutableSetOf = mutableSetOf("jack", "jacky", "jonse")
mutableListOf.add("tom")
mutableListOf.remove("jonse")
mutableListOf += "jarry"
mutableListOf -= "jack"
//集合轉換與快捷函數
//需求把list中的元素去重
val list2 = listOf("jack", "jacky", "jack")
.toSet() // 去重
.toList() //再轉換成list
println(list2)
//kotlin提供了一種快捷的去重函數
val list3 = listOf("jack", "jacky", "jack").distinct()
println(list3)
//數組類型
//kotlin提供各種Array，雖然是引用類型，但可以編譯成java基本數據類型
/**
* 數組類型 創(chuàng)建函數
* IntArray intArrayOf
* DoubleArray dooubleArrayOf
* LongArray longArrayOf
* ShortArray shortArrayOf
* ByteArray byteArrayOf
* FloatArray floatArrayOf
* BooleanArray booleanArrayOf
* Array arrayOf
*/
val intArray = intArrayOf(1, 2, 3)
val toIntArray = listOf(1, 2, 3).toIntArray()
val arrayOf = arrayOf(File("xxxx"), File("xxxxxxxx"))
//map的創(chuàng)建
//to看上去像關鍵字，但事實上，它是個省略了點和參數的特殊函數，to函數將它左邊和右邊的值轉換成一堆Pair
val map = mapOf("guo" to 20, "jin" to 21, "zhang" to 23)
// mapOf(Pair("guo",20),Pair("jin",21),Pair("zhang",23)) 和上面這句代碼一個意思
println(map)
//讀取map的值
/***
* []取值運算符，讀取鍵對應的值，如果鍵不存在返回null
* getValue,讀取鍵對應的值，如果不存在就拋出異常
* getOrElse，讀取鍵對應的值，使用匿名該函數返回默認值
* getOrDefault,讀取鍵對應的值，或者返回默認值
*/
println(map["guo"])
println(map.getValue("guo"))
println(map.getOrElse("aaa"){0})
println(map.getOrDefault("bb",1))
//map的遍歷
map.forEach { (key, value) ->
println("$key $value")
}
map.forEach {
println(it.key + " " + it.value)
}
//map的可變集合
val mutableMap = mutableMapOf("guo" to 1, "jin" to 2, "zhang" to 3)
mutableMap += "li" to 4
mutableMap.put("wang",5)
//獲取對應鍵的值，如果不存在這個鍵，就將這一對鍵值對存入；如果存在，直接取出map中對應的值
println(mutableMap.getOrPut("zheng",{7}))
println(mutableMap)
//定義一個類
class Player{
//kotlin只需要聲明屬性，會自動生成get和set方法。針對定義的每一個屬性，kotlin都會產生一個field。
//field存儲屬性數據，不能自己定義field，kotlin封裝field，只暴露get和set方法
var name = "jack"
//我們也可以重新定義get和set方法
get() = field.capitalize() // 返回首字母大寫的字符串
set(value) {
value.trim()
}
}
//類的主構造函數,主構造函數在類名后加小括號
class Student(
//這里就是主構造函數，它的作用就是賦值給filed值，所以這里就是一個臨時變量的存在，通常都會以下劃線開頭的名字命名
_name : String,
_age : Int,
_isNormal : Boolean
){
//每一個field重寫get和set方法，需要放在其對應的下面。
var name = _name
get() = field.capitalize()
set(value) {
value.trim()
}
var age = _age
var isNormal = _isNormal
}
//kotlin允許不使用臨時變量賦值，而是直接在主構造函數中定義類屬性,這樣可以減少代碼
class Student2(
_name: String,
var age : Int,
var isNormal : Boolean
){
//每一個field重寫get和set方法，需要放在其對應的下面。
var name = _name
get() = field.capitalize()
set(value) {
value.trim()
}
//次構造函數,有主就有次，我們可以定義多個次構造函數來配置不同的參數組合
constructor(_name: String) : this (_name,age = 10,isNormal = false)
//初始化塊，與java的static不一樣，這里的初始化塊是構造函數執(zhí)行的時候，就會執(zhí)行初始化快
init {
//先決函數，如果boolean值是false，執(zhí)行l(wèi)ambda拋出異常
require(age > 0) {
"age must be positive"
}
require(name.isNotBlank()){
"student must have a name"
}
}
}
/**
* 初始化順序
* 1.先初始化主構造函數里聲明的屬性
* 2.類級別的屬性賦值， 這里第二步和第三步的順序調用取決于誰在上誰在下，這是個坑，分上下順序的
* 3.init初始化塊里的屬性賦值和函數調用
* 4.次構造函數里的屬性賦值和函數調用
* 可以在showkotlinbytecode查看調用順序
*/
class Student3(
_name: String,
//第一步執(zhí)行
var age : Int
){
//第二步執(zhí)行
var name = _name
var score = 10//如果這一行寫到init下面，那么init里的score*4就報錯了。。。
init {
println(score*4)
//第三步執(zhí)行
println("init函數執(zhí)行")
}
constructor(name2:String) :this(name2,30){
score =100 //第四步執(zhí)行
}
}
/**
* 延遲初始化
* 使用lateinit關鍵字相當于做了一個約定：在用它之前做初始化
*
*/
class Player2{
lateinit var equipment : String
fun ready(){
equipment = "ak47"
}
fun battle(){
if (::equipment.isInitialized) println(equipment)
}
}
class Player3{
//使用它時再去初始化
val config by lazy { loadConfig() }
private fun loadConfig():String{
println("loading ....")
return "xxx"
}
}
