Swift 提供兩種集合類型來儲存集合，數組和字典。數組是一個同類型的序列化列表集合。字典是一個能夠使用類似於鍵的唯一識別碼來擷取值的非序列化集合。
在Swift中，數組和字典的鍵和值都必須明確它的類型。這意味這數組和字典不會插入一個錯誤的類型的值,以致於出錯。這也意味著當你在數組和字典中取回數值的時候能夠確定它的類型。
Swift 使用確定的集合類型可以保證代碼工作是不會出錯，和讓你在開發階段就能更早的捕獲錯誤。
note：
Swift的數組 儲存不同的類型會展示出不同的行為，例如變數，常量或者 函數和方法。更多的資訊參見Mutability of Collections and Assignment 和 Copy Behavior for Collection Types.
1、數組
數組是儲存同類型不同值的序列化列表。同樣的值可以在數組的不同位置出現多次。
Swift數組是儲存確定的值，這個Objective-C中的NSArray和NSMutableArray類是有區別的。因為它們是儲存各種的對象，而且並不提供返回任何有關對象的具體資訊。在Swift中，無論是確定的聲明，還是隱式的聲明，數組是非常確定它自身是儲存什麼樣的類型，而且，它並不一定要求儲存的是類對象。所以Swift數組是型別安全的，因為它一直都確定它自身所能包含的值。
數組的簡略文法
定義數組的完整寫法是Array<SomeType>。其中SomeType是你想要包含的類型。你也可以使用類似於SomeType[]這樣的簡略文法。雖然這兩種方法在功能上是相同的。但是我們更推薦後者，而且它會一直貫穿於本書。
數組實量（Array Literals）
你可以用一個數組實量（Array Literals）來初始化一個數組，它是用簡略寫法來建立一個包含一個或多個的值的數組。一個數組實量（Array Literals）是由它包含的值，“,”分隔字元 已經包括以上內容的中括弧對“[]”組成：
複製代碼 代碼如下:
[value 1, value 2, value 3]
下面的例子建立一個叫shoppinglist，儲存字串（String）類型的數組。
複製代碼 代碼如下:
var shoppingList: String[] = ["Eggs", "Milk"]
// 使用兩個初始化參數來初始化shoppingList
shoppinglist變數被定義為字串（String）類型的數組，寫作String[]。因為這個數組被確定為字串類型（String），所以它只能儲存字串（String）類型的值。在這裡，用兩個字串類型的值（”Eggs” and “Milk”）和數組實量（Array Literals）的寫法來初始化shoppingList數組。
注意
shoppingList數組是被定義為一個變數（使用var 標識符）而不是常量（使用let 標識符），所以在下面的例子可以直接添加元素。
在這個例子中，數組實量（Array Literals）只包含兩個字串類型的值，這符合了shoppingList變數的定義（只能包含字串（String）類型的數組），所以被分配的數組實量（Array Literals）被允許用兩個字串類型的值來初始化。
得益於Swift的類型推斷，當你用相同類型的值來初始化時，你可以不寫明類型。初始化shoppingList可以用下面這個方法來代替。
複製代碼 代碼如下:
var shoppingList = ["Eggs", “Milk"]
因為數組實量（Array Literals）中所有的值都是同類型的，所以Swift能夠推斷shoppingList的類型為字串數組（String[]）。
讀取和修改數組
你可以通過方法和屬性，或者下標來讀取和修改數組。
通過唯讀屬性count來讀取數組的長度；
複製代碼 代碼如下:
println("The shopping list contains \(shoppingList.count) items.")
// prints "The shopping list contains 2 items.”
通過一個返回布爾類型的isEmpty屬性檢查數組的長度是否為0
複製代碼 代碼如下:
if shoppingList.isEmpty { println("The shopping list is empty.")
} else { println("The shopping list is not empty.")
}
// prints "The shopping list is not empty."
在數組末尾增加一個元素可以通過append方法
複製代碼 代碼如下:
shoppingList.append("Flour")
// shoppingList 現在包含3個元素
甚至，還可以用（+=）操作符來把一個元素添加到數組末尾
複製代碼 代碼如下:
shoppingList += "Baking Powder"
// shoppingList 現在包含4個元素
你也可以用（+=）操作符來把一個數組添加到另一個數組的末尾
複製代碼 代碼如下:
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 現在包含7個元素
從數組中取出一個值可以使用下標文法。如果你知道一個元素的索引值，你可以數組名後面的中括弧中填寫索引值來擷取這個元素
複製代碼 代碼如下:
var firstItem = shoppingList[0]
// firstItem 等於 “Eggs"
注意，數組的第一個元素的索引值為0，不為1，Swift的數組總是索引0；
你可以使用下標文法通過索引修改已經存在的值。
複製代碼 代碼如下:
shoppingList[0] = "Six eggs"
//列表中的第一個值等於"Six eggs" 而不等於 “Eggs"
你可以使用下標文法一次性改變一系列的值，儘管修改的地區遠遠大於要修改的值。在下面的雷子中， 替換掉 “Chocolate Spread”, “Cheese”,”Butter”,”Bananas”,”Apples”:
複製代碼 代碼如下:
shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 現在包含6個元素
注意，你不能使用下標文法在數組中添加一個元素，如果你嘗試使用下標文法來擷取或者設定一個元素，你將得到一個運行時的錯誤。儘管如此，你可以通過count屬性驗證索引是否正確再使用它。當count為0時（意味著數組為空白），則count－1超出了索引的有效範圍，因為數組的索引總是從0開始。
在一個特定的索引位置插入一個值，可以使用insert(atIndex:)方法
複製代碼 代碼如下:
shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 現在包含7個元素
// "Maple Syrup" 在數組的第一位
這裡調用insert方法指明在shoppingList的索引為0的位置中插入一個新元素 “Maple Syrup”
同理，你可以調用removeAtIndex方法移除特定的元素。這個方法移除特定索引位置的元素，已經返回這個被移除的元素（儘管你並不關心這個傳回值）。
複製代碼 代碼如下:
let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引位置為0的元素被移除
// shoppingList 現在包含6個元素, 不包括 Maple Syrup
// mapleSyrup 常量等於被移除的 "Maple Syrup" 字串
當元素被移除的，數組空缺的位置將會被填補，所以現在索引位置為0的元素再一次等於”Six eggs”:
複製代碼 代碼如下:
firstItem = shoppingList[0]
// firstItem 現在等於 "Six eggs”
如果你從數組中移除最後一個元素，使用removeLast方法比removeAtIndex更方便，因為後者需要通過count屬性計算數組的長度。和removeAtIndex方法一樣，removeLast會返回被移除的元素。
複製代碼 代碼如下:
let apples = shoppingList.removeLast()
//元素的最後一個元素被移除
// shoppingList 現在包含5個元素，不包括 cheese
// apples 常量 現在等於被移除的 "Apples" string
遍曆數組
可以使用for－in迴圈來遍曆數組中的值
複製代碼 代碼如下:
for item in shoppingList { println(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas
如果需要每一個元素的整形的索引值，使用enumerate函數代替會更方便，enumerate函數對於每一個元素都會返回一個包含元素的索引和值的元組（tuple）。你可以在遍曆部分分解元祖並儲存在臨時變數或者常量中。
複製代碼 代碼如下:
for (index, value) in enumerate(shoppingList) { println("Item \(index + 1): \(value)")
}
// 元素 1: Six eggs
// 元素 2: Milk
// 元素 3: Flour
// 元素 4: Baking Powder
// 元素 5: Bananas
如需更多for-in 迴圈資訊, 參見 For Loops.
建立和初始化數組
建立一個空的數組和確定的類型（不包含初始化值）使用的初始化文法：
複製代碼 代碼如下:
var someInts = Int[]()
println("someInts is of type Int[] with \(someInts.count) items.")
// prints "someInts is of type Int[] with 0 items.”
注意，someInt變數被確定為Int[]，因為它使用產生Int[]的初始化方法。
或者，如果上下文（context）已經提供類型資訊，例如函數參數或者已經確定類型的常量和變數，你可以從空的數組實量（Array Literals）建立一個空數組，寫作[]（空的中括弧對）。
複製代碼 代碼如下:
someInts.append(3)
// someInts 現在包含1個Int型的元素
someInts = []
// someInts 現在是一個空的數組, 但是類型仍然為Int[];
Swift數群組類型也提供初始化方法來建立確定長度和提供預設數值的數組。你可以通過這個初始化方法增加一個新的數組，元素的數量成為count，合適的預設值為repeatedValue
複製代碼 代碼如下:
var threeDoubles = Double[](count: 3, repeatedValue: 0.0)
// threeDoubles 的類型為 Double[], 以及等於 [0.0, 0.0, 0.0]
得益於類型推斷，你並不需要指明這個數組儲存的類型就能使用這個初始化方法，因為它從預設值中就能推斷出來。
複製代碼 代碼如下:
var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
// anotherThreeDoubles 被推斷為 Double[], 以及等於 [2.5, 2.5, 2.5]
最後，你可以使用（+）操作符就能建立一個新的數組，把兩個存在的數組添加進來
這個新的數群組類型從你添加的兩個數組中推斷出來
複製代碼 代碼如下:
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推斷為 Double[], 並等於 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
2、字典
字典是儲存同一類型但是不同值的容器。每一個值都對應這一個唯一的鍵（Key），就像是字典內的每一個值都有一個標識符。和數組內的元素是有區別的，字典內的元素是沒有特殊的序列的。當你需要根據標識符來尋找批量的值時，就可以使用字典。同樣的，真實的物品字典常常用來當作尋找特定字典的標識符。
Swift字典時儲存一個類型的具體的鍵和值，和Objective-C的NSDictionary 和NSMutableDictionary由一定的區別，因為它們是使用各種的對象來作為它們的鍵和值，而且並不提供任何有關對象的具體資訊。在Swift中，對於一個特定的字典，它所能儲存的鍵和值都是確定的，無論是明確聲明的類型還是隱式推斷的類型。
Swift的字典寫法是Dictionary<KeyType,ValueType>,KeyType是你想要儲存的鍵，ValueType是你想要儲存的值。
唯一的限制就是KeyType必須是可雜湊的（hashable）——就是提供一個形式讓它們自身是獨立識別的。Swift的所有基礎類型（例如字串（String）,整形（Int），雙精確度（Double）和布爾（Bool））在預設是可雜湊的（hashable），和這些類型都常常用語當作字典的鍵。枚舉成員值不需要協助值（associated values）（具體描述在 Enumerations）也是因為它們預設也是可雜湊的（hashable）。
字典實量（Dictionary Literals）
你可以直接用一個字典實量（Dictionary Literals）初始化一個字典。和前面定義一個數組實量（Array Literals）的文法一樣。字典實量（Dictionary Literals）就是使用簡略寫法直接寫一個或者多個的索引值對來定義一個字典。
一個索引值對是一個鍵和值的組合。在字典實量（Dictionary Literals）裡面，每一個索引值對總是用一個冒號把鍵和值分割。索引值對的寫法就想是一個列表，使用逗號分割，並被一對中括弧［］包含著：
複製代碼 代碼如下:
[key 1: value 1, key 2: value 2, key 3: value 3]
在下面的例子，將會建立一個字典來儲存國際機場的名字。在這個字典裡面，鍵是三個字的國際航空運送協會代碼，以及它的值是機場的名稱：
複製代碼 代碼如下:
var airport :Dictionary<String, String> = ["TYO": "Tokyo", "DUB": “Dublin"]
airport字典被定義為一個類型為Dictionary<String, String>，這意味這，這個字典的鍵類型是字串String，和它的值的類型也是String。
注意
airport字典是被定義為一個變數（使用var 標識符）而不是常量（使用let 標識符），所以在下面的例子可以直接添加元素。
airport字典使用一個包含兩個索引值對的字典實量（Dictionary Literals）來初始化。第一對由一個叫“TYO”的鍵和一個叫“Tokyo”的值，第二對有一個叫“DUB”的鍵和一個叫“Dublin”的值。
這個字典實量（Dictionary Literals）包含兩個字串（String）：字串對。這符合airport變數定義的類型（一個字典只包括字串（String）鍵和字串（String）值），所以在分配字典實量（Dictionary Literals）的時候被允許作為airport字典的兩個初始化元素。
和數組一樣，如果你初始化一個字典的時候使用相同的類型，你可以不指明字典的類型。
airport初始化可以用下面這個簡略寫法來代替：
複製代碼 代碼如下:
var airports = ["TYO": "Tokyo", "DUB": “Dublin”]
因為所有的鍵在字面上都是相同的類型，同樣，所有的值也是同樣的類型，所以Swift可以推斷為Dictionary<String, String>是airports字典的正確類型。
讀取和修改字典
你可以通過屬性，方法或者下標來讀取和修改字典。和數組一樣，你使用唯讀count屬性來檢查字典（Dictionary）包含多少個元素。
複製代碼 代碼如下:
println("The dictionary of airports contains \(airports.count) items.")
// prints "The dictionary of airports contains 2 items."
你可以使用下標文法給一個字典添加一個元素。使用合適類型作為新的鍵，並分配給它一個合適的值
複製代碼 代碼如下:
airports["LHR"] = "London"
// airports dictionary 現在有 3 items
你也可以使用下標文法去改變一個特定鍵所關聯的值。
複製代碼 代碼如下:
airports["LHR"] = "London Heathrow"
//"LHR" 的值已經被改變為 "London Heathrow"
同樣, 使用字典的updateValue(forKey:) 方法去設定或者更新一個特定鍵的值 . 和上面的下標例子一樣, updateValue(forKey:) 方法如果鍵不存在則會設定它的值，如果鍵存在則會更新它的值, 和下標不一樣是, updateValue(forKey:) 方法 如果更新時，會返回原來舊的值rThis enables you to 可以使用這個來判斷是否發生了更新。
複製代碼 代碼如下:
updateValue(forKey:) 方法返回一個和字典的值相同類型的可選值. 例如，如果字典的值的類型時String，則會返回String? 或者叫“可選String“，這個可選值包含一個如果值發生更新的舊值和如果值不存在的nil值。
if let oldValue = airports.updateValue("Dublin International", forKey: "DUB") {
println("The old value for DUB was \(oldValue).")
}
// prints "The old value for DUB was Dublin."
你也可以使用下標文法通過特定的鍵去讀取一個值。因為如果他的值不存在的時候，可以返回他的鍵，字典的下標文法會返回一個字典的值的類型的可選值。如果字典中的鍵包含對應的值，這字典下標文法會返回這個鍵所對應的值，否則返回nil
複製代碼 代碼如下:
if let airportName = airports["DUB"] {
println("The name of the airport is \(airportName).")
} else {
println("That airport is not in the airports dictionary.")
}
// prints "The name of the airport is Dublin International."
你可以使用下標文法把他的值分配為nil，來移除這個索引值對。
複製代碼 代碼如下:
airports["APL"] = "Apple International"
// "Apple International" 不是 APL的真實機場,所以刪除它
airports["APL"] = nil
// APL 已經從字典中被移除
同樣，從一個字典中移除一個索引值對可以使用removeValueForKey方法，這個方法如果存在鍵所對應的值，則移除一個索引值對，並返回被移除的值，否則返回nil。
複製代碼 代碼如下:
if let removedValue = airports.removeValueForKey("DUB") {
println("The removed airport's name is \(removedValue).")
} else {
println("The airports dictionary does not contain a value for DUB.")
}
// prints "The removed airport's name is Dublin International."
遍曆字典
你可以使用一個for-in迴圈來遍曆字典的索引值對。字典中的每一個元素都會返回一個元祖（tuple），你可以在迴圈部分分解這個元祖，並用臨時變數或者常量來儲存它。
複製代碼 代碼如下:
for (airportCode, airportName) in airports {
println("\(airportCode): \(airportName)")
}
// TYO: Tokyo
// LHR: London Heathrow
更多有關for-in 迴圈的資訊, 參見 For Loops.
你也可以讀取字典的keys屬性或者values屬性來遍曆這個字典的鍵或值的集合。
複製代碼 代碼如下:
for airportCode in airports.keys {
println("Airport code: \(airportCode)")
}
// Airport code: TYO
// Airport code: LHR
for airportName in airports.values {
println("Airport name: \(airportName)")
}
// Airport name: Tokyo
// Airport name: London Heathrow
如果你需要一個介面來建立一個字典的鍵或者值的數組執行個體，你可以使用keys或者values屬性來初始化一個數值。
複製代碼 代碼如下:
let airportCodes = Array(airports.keys)
// airportCodes is ["TYO", "LHR"]
let airportNames = Array(airports.values)
// airportNames is ["Tokyo", "London Heathrow"]
注意
Swift中的字典類型是非序列化集合，如果你需要序列化取回鍵，值，或者索引值對，遍曆字典不具體敘述。
建立一個空字典
和字典一樣，你可以使用確定類型的文法建立一個空的字典。
複製代碼 代碼如下:
var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers 是一個空的 Dictionary<Int, String> 類型的字典
這個例子建立一個Int，String類型的字典來儲存可讀性較好的整數值。它的鍵是Int類型，以及它們的值是String類型。
如果 上下文（context ）中已經提供類型資訊，可用一個字典實量（Dictionary Literal）建立一個空的字典，寫作[;]（由一對［］包含一個冒號：）
複製代碼 代碼如下:
namesOfIntegers[16] = "sixteen"
// namesOfIntegers現在包含1 個索引值對
namesOfIntegers = [:]
// namesOfIntegers 是一個類型為Int, String的空字典。
注意
在這個情境，Swift數組和字典類型是一個內建的集合。更多的內建類型和集合參見Generics
3、可變集合類型
數組和字典都是在一個集合中一起儲存不同的變數.如果你建立一個數組或者字典，再包含一個變數，建立的這個變數被稱為可變的（mutable） 這意味這，你可以在建立之後增加更多的元素來改變這個集合的長度，或者移除已經包含的。 相反的, 如果你把一個數組或者字典定義為常量，則這個數組或者字典不是可變的，他們的長度並不能被改變。
在字典中，不可變也意味著你不能替換已經存在的鍵的值。一個不可變字典，一旦被設定就不能改變。
數組的不可變有一點點的不同。然而，你仍然不能做任何有可能修改不可變數組的行為。但是你可以重新設定一個已經存在的索引，這使得當Swift的數組的長度確定時，能更好地最佳化數組的效能。
擁有可變行為的數組也影響著數組執行個體的分配和修改，更多內容參見Assignment and Copy Behavior for Collection Types.
注意
在所有的例子中，這是一個好的練習去建立不可變集合，當數組的長度不需要被改變。
我確信Swift編譯器能最佳化好你所建立的集合。
