Swift教程之聚集類型詳解。本站提示廣大學習愛好者：（Swift教程之聚集類型詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是Swift教程之聚集類型詳解正文
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編譯器能優化好你所創立的聚集。
