Swift入門篇-集合

 

一：數組

 

一：可變數組 

    定義：數組使用有序列表存儲相同類型的多重數據。

   格式：

 第一種格式

   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> ()