集合類型

Swift 的所有基本類型（比如 String、Int、Double 和 Bool）默認(rèn)都是可哈?；模梢宰鳛榧现档念愋突蛘咦值滏I的類型。沒有關(guān)聯(lián)值的枚舉成員值（在 枚舉 有講述）默認(rèn)也是可哈?；摹?/p>

注意

你可以使用自定義的類型作為集合值的類型或者是字典鍵的類型，但需要使自定義類型遵循 Swift 標(biāo)準(zhǔn)庫中的 Hashable 協(xié)議。遵循 Hashable 協(xié)議的類型需要提供一個類型為 Int 的可讀屬性 hashValue。由類型的 hashValue 屬性返回的值不需要在同一程序的不同執(zhí)行周期或者不同程序之間保持相同。

因為 Hashable 協(xié)議遵循 Equatable 協(xié)議，所以遵循該協(xié)議的類型也必須提供一個“是否相等”運算符（==）的實現(xiàn)。這個 Equatable 協(xié)議要求任何遵循 == 實現(xiàn)的實例間都是一種相等的關(guān)系。也就是說，對于 a,b,c 三個值來說，== 的實現(xiàn)必須滿足下面三種情況：

• a == a(自反性)
• a == b 意味著 b == a(對稱性)
• a == b && b == c 意味著 a == c(傳遞性)

關(guān)于遵循協(xié)議的更多信息，請看 協(xié)議。

集合類型語法

Swift 中的集合類型被寫為 Set<Element>，這里的 Element 表示集合中允許存儲的類型。和數(shù)組不同的是，集合沒有等價的簡化形式。

創(chuàng)建和構(gòu)造一個空的集合

你可以通過構(gòu)造器語法創(chuàng)建一個特定類型的空集合：

var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// 打印“l(fā)etters is of type Set<Character> with 0 items.”

注意

通過構(gòu)造器，這里 letters 變量的類型被推斷為 Set<Character>。

此外，如果上下文提供了類型信息，比如作為函數(shù)的參數(shù)或者已知類型的變量或常量，你可以通過一個空的數(shù)組字面量創(chuàng)建一個空的集合：

letters.insert("a")
// letters 現(xiàn)在含有1個 Character 類型的值
letters = []
// letters 現(xiàn)在是一個空的 Set，但是它依然是 Set<Character> 類型

用數(shù)組字面量創(chuàng)建集合

你可以使用數(shù)組字面量來構(gòu)造集合，相當(dāng)于一種簡化的形式將一個或者多個值作為集合元素。

下面的例子創(chuàng)建一個稱之為 favoriteGenres 的集合來存儲 String 類型的值：

var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres 被構(gòu)造成含有三個初始值的集合

這個 favoriteGenres 變量被聲明為“一個 String 值的集合”，寫為 Set<String>。由于這個特定集合指定了值為 String 類型，所以它只允許存儲 String 類型值。這里的 favoriteGenres 變量有三個 String 類型的初始值（"Rock"，"Classical" 和 "Hip hop"），以數(shù)組字面量的形式書寫。

注意

favoriteGenres 被聲明為一個變量（擁有 var 標(biāo)示符）而不是一個常量（擁有 let 標(biāo)示符）,因為它里面的元素將會在之后的例子中被增加或者移除。

一個集合類型不能從數(shù)組字面量中被直接推斷出來，因此 Set 類型必須顯式聲明。然而，由于 Swift 的類型推斷功能，如果你想使用一個數(shù)組字面量構(gòu)造一個集合并且與該數(shù)組字面量中的所有元素類型相同，那么無須寫出集合的具體類型。favoriteGenres 的構(gòu)造形式可以采用簡化的方式代替：

var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

由于數(shù)組字面量中的所有元素類型相同，Swift 可以推斷出 Set<String> 作為 favoriteGenres 變量的正確類型。

訪問和修改一個集合

你可以通過集合的屬性和方法來對其進(jìn)行訪問和修改。

為了獲取一個集合中元素的數(shù)量，可以使用其只讀屬性 count：

print("I have \(favoriteGenres.count) favorite music genres.")
// 打印“I have 3 favorite music genres.”

使用布爾屬性 isEmpty 作為一個縮寫形式去檢查 count 屬性是否為 0：

if favoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}
// 打印“I have particular music preferences.”

你可以通過調(diào)用集合的 insert(_:) 方法來添加一個新元素：

favoriteGenres.insert("Jazz")
// favoriteGenres 現(xiàn)在包含4個元素

你可以通過調(diào)用集合的 remove(_:) 方法去刪除一個元素，如果它是該集合的一個元素則刪除它并且返回它的值，若該集合不包含它，則返回 nil。另外，集合可以通過 removeAll() 方法刪除所有元素。

if let removedGenre = favoriteGenres.remove("Rock") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}
// 打印“Rock? I'm over it.”

使用 contains(_:) 方法去檢查集合中是否包含一個特定的值：

if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
} else {
    print("It's too funky in here.")
}
// 打印“It's too funky in here.”

遍歷一個集合

你可以在一個 for-in 循環(huán)中遍歷一個集合中的所有值。

for genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop

更多關(guān)于 for-in 循環(huán)的信息，參見 For 循環(huán)。

Swift 的 Set 類型沒有確定的順序，為了按照特定順序來遍歷一個集合中的值可以使用 sorted() 方法，它將返回一個有序數(shù)組，這個數(shù)組的元素排列順序由操作符 < 對元素進(jìn)行比較的結(jié)果來確定。

for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// Classical
// Hip hop
// Jazz

集合操作

你可以高效地完成集合的一些基本操作，比如把兩個集合組合到一起，判斷兩個集合共有元素，或者判斷兩個集合是否全包含，部分包含或者不相交。

基本集合操作

下面的插圖描述了兩個集合 a 和 b，以及通過陰影部分的區(qū)域顯示集合各種操作的結(jié)果。

• 使用 intersection(_:) 方法根據(jù)兩個集合的交集創(chuàng)建一個新的集合。
• 使用 symmetricDifference(_:) 方法根據(jù)兩個集合不相交的值創(chuàng)建一個新的集合。
• 使用 union(_:) 方法根據(jù)兩個集合的所有值創(chuàng)建一個新的集合。
• 使用 subtracting(_:) 方法根據(jù)不在另一個集合中的值創(chuàng)建一個新的集合。

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]

集合成員關(guān)系和相等

下面的插圖描述了三個集合 a、b 和 c，以及通過重疊區(qū)域表述集合間共享的元素。集合 a 是集合 b 的父集合，因為 a 包含了 b 中所有的元素。相反的，集合 b 是集合 a 的子集合，因為屬于 b 的元素也被 a 包含。集合 b 和集合 c 是不相交的，因為它們之間沒有共同的元素。

• 使用“是否相等”運算符（==）來判斷兩個集合包含的值是否全部相同。
• 使用 isSubset(of:) 方法來判斷一個集合中的所有值是否也被包含在另外一個集合中。
• 使用 isSuperset(of:) 方法來判斷一個集合是否包含另一個集合中所有的值。
• 使用 isStrictSubset(of:) 或者 isStrictSuperset(of:) 方法來判斷一個集合是否是另外一個集合的子集合或者父集合并且兩個集合并不相等。
• 使用 isDisjoint(with:) 方法來判斷兩個集合是否不含有相同的值（是否沒有交集）。

let houseAnimals: Set = ["??", "??"]
let farmAnimals: Set = ["??", "??", "??", "??", "??"]
let cityAnimals: Set = ["??", "??"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

字典

字典是一種無序的集合，它存儲的是鍵值對之間的關(guān)系，其所有鍵的值需要是相同的類型，所有值的類型也需要相同。每個值（value）都關(guān)聯(lián)唯一的鍵（key），鍵作為字典中這個值數(shù)據(jù)的標(biāo)識符。和數(shù)組中的數(shù)據(jù)項不同，字典中的數(shù)據(jù)項并沒有具體順序。你在需要通過標(biāo)識符（鍵）訪問數(shù)據(jù)的時候使用字典，這種方法很大程度上和在現(xiàn)實世界中使用字典查字義的方法一樣。

注意

Swift 的 Dictionary 類型被橋接到 Foundation 的 NSDictionary 類。

更多關(guān)于在 Foundation 和 Cocoa 中使用 Dictionary 類型的信息，參見 Bridging Between Dictionary and NSDictionary。

字典類型簡化語法

Swift 的字典使用 Dictionary<Key, Value> 定義，其中 Key 是一種可以在字典中被用作鍵的類型，Value 是字典中對應(yīng)于這些鍵所存儲值的數(shù)據(jù)類型。

注意

一個字典的 Key 類型必須遵循 Hashable 協(xié)議，就像 Set 的值類型。

你也可以用 [Key: Value] 這樣簡化的形式去表示字典類型。雖然這兩種形式功能上相同，但是后者是首選，并且本教程中涉及到字典類型時通篇采用后者。

創(chuàng)建一個空字典

你可以像數(shù)組一樣使用構(gòu)造語法創(chuàng)建一個擁有確定類型的空字典：

var namesOfIntegers = [Int: String]()
// namesOfIntegers 是一個空的 [Int: String] 字典

這個例子創(chuàng)建了一個 [Int: String] 類型的空字典來儲存整數(shù)的英語命名。它的鍵是 Int 型，值是 String 型。

如果上下文已經(jīng)提供了類型信息，你可以使用空字典字面量來創(chuàng)建一個空字典，記作 [:] （一對方括號中放一個冒號）：

namesOfIntegers[16] = "sixteen"
// namesOfIntegers 現(xiàn)在包含一個鍵值對
namesOfIntegers = [:]
// namesOfIntegers 又成為了一個 [Int: String] 類型的空字典

用字典字面量創(chuàng)建字典

你可以使用字典字面量來構(gòu)造字典，這和剛才介紹過的數(shù)組字面量擁有相似語法。字典字面量是一種將一個或多個鍵值對寫作 Dictionary 集合的快捷途徑。

一個鍵值對是一個鍵和一個值的結(jié)合體。在字典字面量中，每一個鍵值對的鍵和值都由冒號分割。這些鍵值對構(gòu)成一個列表，其中這些鍵值對由逗號分割、并整體被包裹在一對方括號中：

[key 1: value 1, key 2: value 2, key 3: value 3]

下面的例子創(chuàng)建了一個存儲國際機(jī)場名稱的字典。在這個字典中鍵是三個字母的國際航空運輸相關(guān)代碼，值是機(jī)場名稱：

var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

airports 字典被聲明為一種 [String: String] 類型，這意味著這個字典的鍵和值都是 String 類型。

注意

airports 字典被聲明為變量（用 var 關(guān)鍵字）而不是常量（用 let 關(guān)鍵字）因為后面會有更多的機(jī)場信息被添加到這個字典中。

airports 字典使用字典字面量初始化，包含兩個鍵值對。第一對的鍵是 YYZ，值是 Toronto Pearson。第二對的鍵是 DUB，值是 Dublin。

這個字典語句包含了兩個 String: String 類型的鍵值對。它們對應(yīng) airports 變量聲明的類型（一個只有 String 鍵和 String 值的字典），所以這個字典字面量的賦值是一種方式用來構(gòu)造擁有兩個初始數(shù)據(jù)項的 airport 字典。

和數(shù)組一樣，你在用字典字面量構(gòu)造字典時，如果它的鍵和值都有各自一致的類型，那么就不必寫出字典的類型。 airports 字典也可以用這種簡短方式定義：

var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

因為這個語句中所有的鍵和值都各自擁有相同的數(shù)據(jù)類型，Swift 可以推斷出 [String: String] 是 airports 字典的正確類型。

訪問和修改字典

你可以通過字典的方法和屬性來訪問和修改字典，或者通過使用下標(biāo)語法。

和數(shù)組一樣，可以通過 Dictionary 的只讀屬性 count 來獲取字典的數(shù)據(jù)項數(shù)量：

print("The dictionary of airports contains \(airports.count) items.")
// 打印“The dictionary of airports contains 2 items.”（這個字典有兩個數(shù)據(jù)項）

使用布爾屬性 isEmpty 作為一個縮寫形式去檢查 count 屬性是否為 0：

if airports.isEmpty {
    print("The airports dictionary is empty.")
} else {
    print("The airports dictionary is not empty.")
}
// 打印“The airports dictionary is not empty.”

你可以通過下標(biāo)語法來給字典添加新的數(shù)據(jù)項。可以使用一個恰當(dāng)類型的鍵作為下標(biāo)索引，并且分配恰當(dāng)類型的新值：

airports["LHR"] = "London"
// airports 字典現(xiàn)在有三個數(shù)據(jù)項

也可以使用下標(biāo)語法來改變特定鍵對應(yīng)的值：

airports["LHR"] = "London Heathrow"
// “LHR”對應(yīng)的值被改為“London Heathrow”

作為一種替代下標(biāo)語法的方式，字典的 updateValue(_:forKey:) 方法可以設(shè)置或者更新特定鍵對應(yīng)的值。就像上面所示的下標(biāo)示例，updateValue(_:forKey:) 方法在這個鍵不存在對應(yīng)值的時候會設(shè)置新值或者在存在時更新已存在的值。和下標(biāo)的方式不同，updateValue(_:forKey:) 這個方法返回更新值之前的原值。這樣使得你可以檢查更新是否成功。

updateValue(_:forKey:) 方法會返回對應(yīng)值類型的可選類型。舉例來說：對于存儲 String 值的字典，這個函數(shù)會返回一個 String? 或者“可選 String”類型的值。如果有值存在于更新前，則這個可選值包含了舊值，否則它將會是 nil ：

if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// 輸出“The old value for DUB was Dublin.”

你也可以使用下標(biāo)語法來在字典中檢索特定鍵對應(yīng)的值。因為有可能請求的鍵沒有對應(yīng)的值存在，字典的下標(biāo)訪問會返回對應(yīng)值類型的可選類型。如果這個字典包含請求鍵所對應(yīng)的值，下標(biāo)會返回一個包含這個存在值的可選類型，否則將返回 nil：

if let airportName = airports["DUB"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport is not in the airports dictionary.")
}
// 打印“The name of the airport is Dublin Airport.”

還可以使用下標(biāo)語法通過將某個鍵的對應(yīng)值賦值為 nil 來從字典里移除一個鍵值對：

airports["APL"] = "Apple Internation"
// “Apple Internation”不是真的 APL 機(jī)場，刪除它
airports["APL"] = nil
// APL 現(xiàn)在被移除了

此外，removeValue(forKey:) 方法也可以用來在字典中移除鍵值對。這個方法在鍵值對存在的情況下會移除該鍵值對并且返回被移除的值或者在沒有對應(yīng)值的情況下返回 nil：

if let removedValue = airports.removeValue(forKey: "DUB") {
    print("The removed airport's name is \(removedValue).")
} else {
    print("The airports dictionary does not contain a value for DUB.")
}
// 打印“The removed airport's name is Dublin Airport.”

字典遍歷

你可以使用 for-in 循環(huán)來遍歷某個字典中的鍵值對。每一個字典中的數(shù)據(jù)項都以 (key, value) 元組形式返回，并且可以使用臨時常量或者變量來分解這些元組：

for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
// YYZ: Toronto Pearson
// LHR: London Heathrow

更多關(guān)于 for-in 循環(huán)的信息，參見 For 循環(huán)。

通過訪問 keys 或者 values 屬性，你也可以遍歷字典的鍵或者值：

for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}
// Airport code: YYZ
// Airport code: LHR

for airportName in airports.values {
    print("Airport name: \(airportName)")
}
// Airport name: Toronto Pearson
// Airport name: London Heathrow

如果你需要使用某個字典的鍵集合或者值集合來作為某個接受 Array 實例的 API 的參數(shù)，可以直接使用 keys 或者 values 屬性構(gòu)造一個新數(shù)組：

let airportCodes = [String](airports.keys)
// airportCodes 是 ["YYZ", "LHR"]

let airportNames = [String](airports.values)
// airportNames 是 ["Toronto Pearson", "London Heathrow"]

Swift 的 Dictionary 是無序集合類型。為了以特定的順序遍歷字典的鍵或值，可以對字典的 keys 或 values 屬性使用 sorted() 方法。