一：數組
一：可變數組 定義：數組使用有序列表存儲相同類型的多重數據。 格式： 第一種格式 var 變量: 類型[] = [變量值，變量值,...] 第二種格式 var 變量 ＝[變量值，變量值,...] 說明： 1：[變量值，變量值...] 這樣表示數組 ，前提是 變量值的類型必須一值。（和其他語言有所不同） 2：上面兩種格式都是定義一個數組，數組中的變量值的類型必須一致 3：第一種格式定義的數組，是直接定義數組，第二種格式定義的數組 是編譯器通過類型值推導出是數組格式
注意點 1：常量關鍵字（let) 定義的數組，不可變數組是不能做任何修改，只能訪問。 2：變量關鍵字（var) 定義的數組 ，可變數組可以修改，可以訪問。
例子
//-------數組的定義------------ /* 1：["hello","swift"] -->[]里面包含的變量值類型都是字符串，即是字符串可變數組 2；編譯器通過["hello","swift"] 來推斷 arr變量的類型是字符串可變數組類型 */ var arr = ["hello","swift"] /* 1：var arr1:String[]--->直接定義arr1 是字符串可變數組類型，其數組中值必須為字符串 */ var arr1:String[] = ["hello","swift"] println("arr =\(arr), arr1=\(arr1)") 運行結果 arr =[hello, swift], arr1=[hello, swift]
注意點
var str = [" hellow",11] println("str =\(str)") 運行結果 str =( " hellow", 11 ) /* 1：[" hellow",11] -->[] 變量值類型是字符串和整形，類型不一致，即不是數組 2：結果(" hellow",11) 是一個不可變數組 */
可變數組的操作
①：數組的長度和數組變量值修改
//-----------數組的長度---- var Arr = ["hell0","swift"] var count = Arr.count //count 屬性 返回 數組的長度 println( "count=\(count)") //------------數組中變量值的修改------ var str = [81,82,85] str[2] = 83 //str[2] 指的是數組中索引為2的變量值即85 重新賦值為83 println("str=\(str)") 運行結果： count=2 str=[81, 82, 83]
②：可變數組的追加 += append
//-------數組的追加---appped()函數------------ var arr = [1,2] //定義整形數組變量arr arr.append(3)//append(3) 是在arr數組的尾端追加變量值3到數組中 即數組長度增加1 println(" arr = \(arr) 長度＝\(arr.count)") //-------數組的追加--- +＝ ------------ var arr1 = [10,11] //定義整形數組變量arr arr1 += 12 // += 是在arr數組的尾端追加變量值3到數組中 數組長度增加1 （內部實現原理 也會用到append函數） println(" arr1= \(arr1) 長度＝\(arr1.count)") 運行結果 arr = [1, 2, 3] 長度＝3 arr1= [10, 11, 12] 長度＝3
③: 可變數組的插入 Insert(變量值 , atIndex: 索引)
//-------數組的追加 --- Insert(變量值 ,atIndex:索引）----------- var arr2 = [10,11] arr2.insert(9,atIndex:0) // 在數組arr中0的位置插入變量值9 數組長度加1 println("arr2=\(arr2) 長度＝\(arr2.count)") 運行結果 arr2=[9, 10, 11] 長度＝3
3: 可變數組的移除 removeAtIndex（索引）,removeLast()
//--------------數組的移除 removeLast() 數組尾端移除變量值---- var arr4 = [200,201,202] arr4.removeLast() //移除數組arr3中尾端的 的變量值，數組長度減1 println(" arr4 =\(arr4) 長度＝\(arr4.count)") //--------------數組的移除 removeAtIndex（索引）數組指定位置移除變量值---- var arr3 = [100,101,102] arr3.removeAtIndex(0)//移除數組arr3中索引為0 的變量值，數組長度減1 println("arr3 =\(arr3) 長度＝\(arr3.count)") 運行結果 arr4 =[200, 201] 長度＝2 arr3 =[101, 102] 長度＝2
4:創建空數組
①：定義可變空數組
格式： 變量關鍵字 變量 ＝ 類型[] () 例子： var arr = Int[]() 注意點： 1：常量關鍵字(let) 修辭的數組是不可變數組，不能修改，定義空字符數組沒有意義 2：變量關鍵字(var） 修辭的數組，是可變數組 實在是能動態改變的。
②：IsEmpty 函數判斷數組是否為空
//-----------空數組---- /* 1: Int[] () 是整形空數組 2: arr 數組變量 被let 修辭 ，arr數組只能訪問 */ let arr = Int[] () /* 1: Int[] () 是整形空數組 2: arr1 數組變量 被var 修辭 ，arr數組是可變數組，可以動態修改 */ var arr1 = Int[] () arr1 += 1 println("arr1= \(arr1)") //-----------判斷數組是否為空--- var arr2 = Int[] () if arr2.isEmpty { //isEmpth 是判斷數組是否是空數組 println("arr2 數組為空") } else{ println("arr2 數組不為空") } 運行結果 arr1= [1] arr2 數組為空
數組的遍歷 for in (前面文章講過用法）
//------------數組的訪問-- for in ----- var arr = ["hello","swift"] for str in arr { // for 變量 in 集合 當執行for in的時候 集合中變量值會依次賦值給str println(str) } 運行結果： hello swift
二：可變字典
一：可變字典 定義：字典是一種存儲相同類型多重數據的存儲器。每個值（value）都關聯獨特的鍵（key），鍵作為字典中的這個值數據的標識符 格式： 第一種格式 變量 變量: Dictionary<類型,類型> = [變量值:變量值，變量值:變量值,...] 第二種格式 變量 變量 ＝[變量值:變量值，變量值：變量值,...] 說明： 例子： 第一種格式： var dic:Dictionary<String ,Int>= ["H1":1,"H2":2]
第二種格式： var dic = ["H1":1,"H2":2] 說明： 字典規范 1：[]中由 key:value 鍵值組成的 2：所有key 的類型必須一直， 所有value的類型必須一致，所有key不能重復 3：第一種格式定義的字典，是直接定義字典，第二種格式定義的數組 是編譯器通過類型值推導出是字典格式
注意點： 1：常量關鍵字（let) 定義的字典，是不可字典，是不能做任何修改，只能訪問。 2：變量關鍵字（var) 定義的字典 ，是可變字典，是可以修改，可以訪問。
例子：
/* 1: [] 里面有key:value組成 2: 所有key的類型一直並且不重復，所有value類型一致 3：即 ["H1":1 ,"H2":2] 是一字典類型 ，編譯器通過字典類型推導出 dic是可變字典 */ var dic = ["H1":1 ,"H2":2] println("dic=\(dic)") /* 1:var dic1:Dictionary<String ,Int> 直接定義可變字典類型中key 為字符串 value 為整形 2：key中字符不能重復 */ var dic1:Dictionary<String ,Int> = ["H1":1 ,"H2":2] println("dic1=\(dic1)") 運行結果 dic=[H1: 1, H2: 2] dic1=[H1: 1, H2: 2]
注意點：
/* 1：[] 是有key:value 組成 2：key 類型一直，不重復，但是value 類型不一致即是不可變字典 */ var str = ["str":1 ,"hell0":"swift"] println(str)
可變字典 修改值
1：updateValue(修改值, forKey key值）
2：通過[key] 來修改value 的值
//-------------通過key來修改value---updateValue(修改值, forKey key值） /* 1：[] 是有key:value 組成 2：key 類型一致，不充分是value 類型一致即是可變字典 */ var str = ["str":"aa" ,"hell0":"swift"] str.updateValue("bb" ,forKey:"str") println("str =\(str)") //-------------通過key來修改value---同[key]來修改value 的值 var str1 = ["str":"aa" ,"hell0":"swift"] str1["str"] = "cc" //字典同key（str) 直接修改key對應value println("str1=\(str1)") 運行結果： str =[str: bb, hell0: swift] str1=[str: cc, hell0: swift]
可變字典 -- 通過key 得到value的值 即value的是一個可選值。
/* 1：[] 是有key:value 組成 2：key 類型一致，不充分是value 類型一致即是可變字典 */ var str = ["str":"aa" ,"hell0":"swift"] var temp = str["Str"] //訪問字典不存在的key ,返回值為nil var temp1 = str["str"] //訪問字典存在的key,返回對應的value println("temp=\(temp),temp1 = \(temp1)") // 總結 str[key] 返回值可能是正確，也有可能是返回nil 即 str[key] 返回值是可選值 運行結果; temp=nil,temp1 = aa
字典的遍歷 ----for in
var dic = ["hello":1 , "swift":2] // for 元組 in 字典集合 用元組來表示字典中對應的鍵值 for (key,value) in dic { println("key=\(key),value=\(value)") }
創建一個空的可變字典
格式 ： var 變量 = Dictionary<key類型，value類型（）
//創建一個key為字符串 value 為整形的空字典，並且字典為可變字典 var arr = Dictionary<String,Int> ()