集合類型
Swift提供了三種主要的集合類型，稱為數組，集合和字典，用于存儲值的集合。數組是有序的值集合。集合是唯一值的無序集合。字典是鍵值關聯的無序集合。
<figure class="figure" style="font-size: 0.8rem;">[圖片上傳失敗...(image-cc24e-1531103372854)]
</figure>
Swift中的數組，集合和字典總是清楚它們可以存儲的值和鍵的類型。這意味著您不能錯誤地將錯誤類型的值插入到集合中。這也意味著您可以確信您將從集合中檢索的值的類型。
注意
Swift的數組，集合和字典類型被實現為通用集合。有關泛型類型和集合的更多信息，請參閱泛型。
集合的可變性
如果您創建數組，集合或字典，并將其分配給一個變量，則創建的集合將是可變的。這意味著，你可以改變（或變異它是由添加，刪除或改變集合中的項目創建后）的集合。如果將數組，集合或字典分配給常量，那么該集合是不可變的，并且其大小和內容不能更改。
注意
在集合不需要改變的所有情況下創建不可變集合是一個好習慣。這樣做可以讓您更輕松地推理代碼，并使Swift編譯器能夠優化您創建的集合的性能。
數組
一個陣列存儲在有序列表中的相同類型的值。相同的值可以在不同位置多次出現在陣列中。
注意
斯威夫特的Array類型被橋接到基金會的NSArray班級。
有關使用的詳細信息Array與基金會和可可，看到與可可數據類型的工作中使用斯威夫特與可可和Objective-C（雨燕4.1） 。
數組類型速記語法
Swift數組的類型完全寫成Array<Element>，其中Element數組允許存儲的值的類型在哪里。你也可以用簡寫形式寫出數組的類型[Element]。盡管這兩種形式在功能上是相同的，但是在引用數組類型時，速記形式是優選的，并且貫穿本指南。
創建一個空數組
您可以使用初始化語法創建一個特定類型的空數組：
var someInts = [Int]()print("someInts is of type [Int] with \(someInts.count) items.")// Prints "someInts is of type [Int] with 0 items."
請注意，someInts變量的類型被推斷為[Int]來自初始值設定項的類型。
或者，如果上下文已經提供了類型信息，例如函數參數或已經存在類型的變量或常量，則可以創建一個空數組，其中包含一個空數組文本，該文本寫為[]（一對空括號）：
someInts.append(3)// someInts now contains 1 value of type IntsomeInts = []// someInts is now an empty array, but is still of type [Int]
用默認值創建一個數組
Swift的Array類型還提供了一個初始化器，用于創建一個具有特定大小的數組，并將其所有值設置為相同的默認值。您將此初始值設定項傳遞給適當類型（調用repeating）的默認值：以及在新數組（調用count）中重復該值的次數：
var threeDoubles = Array(repeating: 0.0, count: 3)// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]
通過一起添加兩個數組來創建一個數組
您可以通過使用添加運算符（+）添加具有兼容類型的兩個現有數組來創建新數組。新數組的類型是根據您添加在一起的兩個數組的類型推斷的：
var anotherThreeDoubles = Array(repeating: 2.5, count: 3)// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5]var sixDoubles = threeDoubles + anotherThreeDoubles// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
使用數組字面值創建數組
您還可以使用數組文本初始化數組，這是將一個或多個值作為數組集合寫入的簡寫方法。數組文字被寫為一列值，用逗號分隔，并由一對方括號包圍：
- <pre class="code-voice" style="margin: 8px 0px; font-size: 0.85rem;">[ 值1，值2，值3 ]</pre>
下面的示例創建一個調用shoppingList以存儲String值的數組：
var shoppingList: [String] = ["Eggs", "Milk"]// shoppingList has been initialized with two initial items
該shoppingList變量被聲明為“字符串值的數組”，寫為[String]。由于此特定數組已指定值類型String，因此只允許存儲String值。在這里，shoppingList數組被初始化為兩個String值（"Eggs"和"Milk"），寫入數組文字中。
注意
該shoppingList數組被聲明為一個變量（與var介紹人），而不是一個常量（與let介紹人），因為更多的項目被添加到下面的例子中的購物清單。
在這種情況下，數組文字包含兩個String值，沒有別的。這與shoppingList變量聲明的類型（一個只能包含String值的數組）相匹配，因此允許使用數組文本的賦值作為初始化shoppingList兩個初始項的方法。
感謝Swift的類型推斷，如果使用包含相同類型值的數組字面值初始化數組，則不必編寫數組的類型。初始化shoppingList本來可以用較短的形式寫成：
var shoppingList = ["Eggs", "Milk"]
因為數組文本中的所有值都是相同的類型，所以Swift可以推斷出這[String]是用于shoppingList變量的正確類型。
訪問和修改數組
您可以通過其方法和屬性或使用下標語法來訪問和修改數組。
要找出數組中項目的數量，請檢查其只讀count屬性：
print("The shopping list contains \(shoppingList.count) items.")// Prints "The shopping list contains 2 items."
使用Boolean isEmpty屬性作為檢查count屬性是否等于的快捷方式0：
if shoppingList.isEmpty {print("The shopping list is empty.")} else {print("The shopping list is not empty.")}// Prints "The shopping list is not empty."
您可以通過調用數組的append(_:)方法將新項添加到數組的末尾：
shoppingList.append("Flour")// shoppingList now contains 3 items, and someone is making pancakes
或者，使用添加賦值運算符（+=）添加一個或多個兼容項目的數組：
shoppingList += ["Baking Powder"]// shoppingList now contains 4 itemsshoppingList += ["Chocolate Spread", "Cheese", "Butter"]// shoppingList now contains 7 items
使用subscript語法從數組中檢索一個值，并在數組名稱后立即傳遞要檢索的方括號內的值的索引：
var firstItem = shoppingList[0]// firstItem is equal to "Eggs"
注意
數組中的第一個項目的索引是0，而不是1。Swift中的數組始終為零索引。
您可以使用下標語法來更改給定索引處的現有值：
shoppingList[0] = "Six eggs"// the first item in the list is now equal to "Six eggs" rather than "Eggs"
當使用下標語法時，您指定的索引需要有效。例如，編寫shoppingList[shoppingList.count] = "Salt"試圖將項添加到數組的末尾會導致運行時錯誤。
即使替換值的長度與要替換的范圍不同，您也可以使用下標語法一次更改一系列值。下面的示例替換"Chocolate Spread"，"Cheese"以及"Butter"與"Bananas"和"Apples"：
shoppingList[4...6] = ["Bananas", "Apples"]// shoppingList now contains 6 items
要將一個項目插入到指定索引處的數組中，請調用該數組的insert(_:at:)方法：
shoppingList.insert("Maple Syrup", at: 0)// shoppingList now contains 7 items// "Maple Syrup" is now the first item in the list
這個insert(_:at:)方法的調用插入一個新的項目，其值為"Maple Syrup"購物清單的最開始處，由索引為0。
同樣，您可以使用該remove(at:)方法從數組中移除一個項目。此方法刪除指定索引處的項目并返回刪除的項目（但如果不需要，您可以忽略返回的值）：
let mapleSyrup = shoppingList.remove(at: 0)// the item that was at index 0 has just been removed// shoppingList now contains 6 items, and no Maple Syrup// the mapleSyrup constant is now equal to the removed "Maple Syrup" string
注意
如果您嘗試訪問或修改數組現有邊界之外的索引的值，則會觸發運行時錯誤。通過將索引與數組的count屬性進行比較，可以檢查索引是否有效。數組中最大的有效索引是count - 1因為數組從零開始索引 - 但是，當countis 0（意味著數組為空）時，沒有有效的索引。
當一個項目被刪除時，數組中的任何間隙都會關閉，因此index 0處的值再次等于"Six eggs"：
firstItem = shoppingList[0]// firstItem is now equal to "Six eggs"
如果要從數組中移除最后一項，請使用removeLast()方法而不是remove(at:)方法來避免查詢數組的count屬性。像該remove(at:)方法一樣，removeLast()返回已刪除的項目：
let apples = shoppingList.removeLast()// the last item in the array has just been removed// shoppingList now contains 5 items, and no apples// the apples constant is now equal to the removed "Apples" string
迭代數組
可以遍歷整個集合值與數組for- in循環：
for item in shoppingList {print(item)}// Six eggs// Milk// Flour// Baking Powder// Bananas
如果您需要每個項目的整數索引及其值，請使用該enumerated()方法遍歷數組。對于數組中的每個項目，該enumerated()方法返回一個由整數和項目組成的元組。整數從零開始，每個項目加1; 如果您枚舉整個數組，這些整數與項目的索引匹配。作為迭代的一部分，您可以將元組分解為臨時常量或變量：
for (index, value) in shoppingList.enumerated() {print("Item \(index + 1): \(value)")}// Item 1: Six eggs// Item 2: Milk// Item 3: Flour// Item 4: Baking Powder// Item 5: Bananas
有關for- in循環的更多信息，請參閱For-In循環。
集
一個集合在同一個集合中存儲相同類型的不同值并且沒有定義的順序。當項目順序不重要時，或者需要確保項目只出現一次時，您可以使用一個集合而不是一個數組。
注意
斯威夫特的Set類型被橋接到基金會的NSSet班級。
有關使用的詳細信息Set與基金會和可可，看到與可可數據類型的工作中使用斯威夫特與可可和Objective-C（雨燕4.1） 。
集合類型的哈希值
一個類型必須是可散列的才能存儲在一個集合中 - 也就是說，該類型必須提供一種為自己計算散列值的方法。哈希值是Int是對于同樣比較所有對象，例如，如果相同的值a == b，它遵循a.hashValue == b.hashValue。
所有斯威夫特的基本類型（例如String，Int，Double，和Bool）默認情況下可哈希，并可以作為設定值類型或字典密鑰類型。沒有關聯值的枚舉大小寫值（如枚舉中所述）默認情況下也是可哈希的。
注意
您可以使用自己的自定義類型作為設置值類型或字典鍵類型，使其符合HashableSwift標準庫中的協議。符合Hashable協議的類型必須提供一個Int名為gettable的屬性hashValue。類型hashValue屬性返回的值不需要在同一程序的不同執行過程中或在不同的程序中相同。
由于Hashable協議符合Equatable，符合類型還必須提供equals運算符（==）的實現。該Equatable協議要求任何符合實現==的等價關系。也就是說，一個實現==必須滿足以下三個條件，所有值a，b以及c：
a == a（自反）a == b暗示b == a（對稱）a == b && b == c意味著a == c（傳遞性）
有關符合協議的更多信息，請參閱協議。
設置類型語法
Swift集合的類型被寫為Set<Element>，Element集合允許存儲的類型在哪里。與數組不同，集合不具有等效的速記形式。
創建并初始化一個空集
您可以使用初始化語法創建一個特定類型的空集：
var letters = Set<Character>()print("letters is of type Set<Character> with \(letters.count) items.")// Prints "letters is of type Set<Character> with 0 items."
注意
根據初始值設定項的類型letters推斷變量Set<Character>的類型是。
或者，如果上下文已經提供了類型信息，例如函數參數或已經存在類型的變量或常量，則可以使用空數組文本創建一個空集：
letters.insert("a")// letters now contains 1 value of type Characterletters = []// letters is now an empty set, but is still of type Set<Character>
使用數組文字創建一個集合
您還可以使用數組文本初始化一個集合，作為將一個或多個值作為集合集合寫入的簡寫方法。
下面的示例創建一個調用favoriteGenres存儲String值的集合：
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]// favoriteGenres has been initialized with three initial items
該favoriteGenres變量被聲明為“一組String值”，寫為Set<String>。因為這個特定的集合已經指定了一個值類型String，所以只允許存儲String值。在此，favoriteGenres集合被初始化具有三個String值（"Rock"，"Classical"，和"Hip hop"），陣列字面內寫入。
注意
該favoriteGenres集被聲明為一個變量（與var介紹人），而不是一個常量（與let介紹人），因為在下面的例子中添加和刪除了項目。
集合類型不能單獨從數組文本中推斷出來，所以Set必須明確聲明類型。但是，由于Swift的類型推斷，如果使用包含相同類型值的數組字面值初始化它，則不必編寫該類型的集合。初始化favoriteGenres本來可以用較短的形式寫成：
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
因為數組文本中的所有值都是相同的類型，所以Swift可以推斷出這Set<String>是用于favoriteGenres變量的正確類型。
訪問和修改集合
你可以通過它的方法和屬性來訪問和修改一個集合。
要找出一組中的項目數量，請檢查其只讀count屬性：
print("I have \(favoriteGenres.count) favorite music genres.")// Prints "I have 3 favorite music genres."
使用Boolean isEmpty屬性作為檢查count屬性是否等于的快捷方式0：
if favoriteGenres.isEmpty {print("As far as music goes, I'm not picky.")} else {print("I have particular music preferences.")}// Prints "I have particular music preferences."
您可以通過調用set的insert(_:)方法將新項目添加到集合中：
favoriteGenres.insert("Jazz")// favoriteGenres now contains 4 items
您可以通過調用set的remove(_:)方法從集合中刪除一個項目，如果該項目是該集合的成員，則該項目將移除該項目，并返回已移除的值; nil如果該集合未包含該項目，則返回該值。或者，可以使用其removeAll()方法刪除集合中的所有項目。
if let removedGenre = favoriteGenres.remove("Rock") {print("\(removedGenre)? I'm over it.")} else {print("I never much cared for that.")}// Prints "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.")}// Prints "It's too funky in here."
迭代集合
您可以使用for- in循環遍歷集合中的值。
for genre in favoriteGenres {print("\(genre)")}// Jazz// Hip hop// Classical
有關for- in循環的更多信息，請參閱For-In循環。
Swift的Set類型沒有定義的順序。要按特定順序迭代集合的值，請使用該sorted()方法，該方法將集合的元素作為使用<運算符排序的數組返回。
for genre in favoriteGenres.sorted() {print("\(genre)")}// Classical// Hip hop// Jazz
執行集合操作
您可以高效地執行基本集合操作，例如將兩個集合組合在一起，確定兩個集合具有哪些值，或確定兩個集合是包含全部，部分還是不包含相同的值。
基本設置操作
下圖描繪了兩個集- a和b-附由陰影區域表示的各種設定操作的結果。
<figure class="figure" style="font-size: 0.8rem;">[圖片上傳失敗...(image-f83059-1531103372853)]
</figure>
使用該
intersection(_:)方法創建一個僅具有兩個集合通用值的新集合。使用該
symmetricDifference(_:)方法創建一個新的集合，其中任何一個集合中都有值，但不能同時包含兩個值使用該
union(_:)方法創建一個包含兩個集合中所有值的新集合。使用該
subtracting(_:)方法創建一個新的集合，其值不在指定的集合中。
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]
設置成員資格和平等
下面的插圖描述了三個集合a，b以及c表示在集合之間共享元素的重疊區域。Set a是集合的超集b，因為a包含了所有元素b。相反，set b是集合的一個子集a，因為所有元素b都包含在內a。Set b和Set c是彼此分離的，因為它們沒有共同的元素。
<figure class="figure" style="font-size: 0.8rem;">[圖片上傳失敗...(image-b5bc-1531103372853)]
</figure>
使用“is equal”運算符（
==）來確定兩個集合是否包含所有相同的值。使用該
isSubset(of:)方法確定一個集合的所有值是否都包含在指定的集合中。使用該
isSuperset(of:)方法來確定一個集合是否包含指定集合中的所有值。使用
isStrictSubset(of:)orisStrictSuperset(of:)方法來確定一個集合是一個子集或超集，但不等于一個指定的集合。使用該
isDisjoint(with:)方法確定兩個集合是否沒有共同的值。
let houseAnimals: Set = ["??", "??"]let farmAnimals: Set = ["??", "??", "??", "??", "??"]let cityAnimals: Set = ["??", "??"]houseAnimals.isSubset(of: farmAnimals)// truefarmAnimals.isSuperset(of: houseAnimals)// truefarmAnimals.isDisjoint(with: cityAnimals)// true
字典
甲字典存儲相同類型的密鑰和一個集合中的相同類型的值與沒有定義排序之間的關聯。每個值都與一個唯一鍵相關聯，該鍵用作字典中該值的標識符。與數組中的項目不同，字典中的項目沒有指定的順序。當需要根據標識符查找值時，您可以使用字典，這與使用真實世界字典查找特定字詞的定義的方式大致相同。
注意
斯威夫特的Dictionary類型被橋接到基金會的NSDictionary班級。
有關使用的詳細信息Dictionary與基金會和可可，看到與可可數據類型的工作中使用斯威夫特與可可和Objective-C（雨燕4.1） 。
字典類型速記語法
Swift字典的類型完全寫成Dictionary<Key, Value>，其中Key是可以用作字典鍵Value的值的類型，并且是字典為這些鍵存儲的值的類型。
注意
字典Key類型必須符合Hashable協議，就像集合的值類型一樣。
您也可以用簡寫形式書寫字典的類型[Key: Value]。盡管這兩種形式在功能上是相同的，但是在引用字典類型時，縮寫形式是優選的，并且貫穿本指南。
創建一個空字典
與數組一樣，您可以Dictionary使用初始化語法創建一個空的某種類型：
var namesOfIntegers = [Int: String]()// namesOfIntegers is an empty [Int: String] dictionary
這個例子創建一個空的字典類型[Int: String]來存儲可讀的整數值名稱。它的鍵是類型的Int，它的值是類型的String。
如果上下文已經提供了類型信息，則可以創建一個空字典，其中包含一個空字典文字，該文字被寫為[:]（一對方括號內的冒號）：
namesOfIntegers[16] = "sixteen"// namesOfIntegers now contains 1 key-value pairnamesOfIntegers = [:]// namesOfIntegers is once again an empty dictionary of type [Int: String]
使用字典文字創建字典
您還可以使用字典文字來初始化字典，它具有與前面所看到的數組字面相似的語法。字典文字是將一個或多個鍵值對寫入Dictionary集合的簡寫方法。
甲鍵值對是一個鍵和值的組合。在字典文字中，每個鍵 - 值對中的鍵和值由冒號分隔。鍵值對寫成一個列表，用逗號分隔，并用一對方括號包圍：
- <pre class="code-voice" style="margin: 8px 0px; font-size: 0.85rem;">[ 鍵1：值1，鍵2：值2，鍵3：值3 ]</pre>
下面的示例創建一個字典來存儲國際機場的名稱。在這本詞典中，關鍵字是三個字母的國際航空運輸協會代碼，其值是機場名稱：
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
該airports字典被聲明為具有式的[String: String]，意思是“一Dictionary鍵均為類型的String，并且其值是類型的也String”。
注意
該airports字典被聲明為一個變量（與var導引器），而不是一個常數（與let導引器），因為更多的機場被添加到詞典中下面的例子。
該airports字典被初始化與含有兩個鍵-值對的字典字面值。第一對有一個鍵"YYZ"和一個值"Toronto Pearson"。第二對有一個鍵"DUB"和一個值"Dublin"。
這個字典文字包含兩String: String對。這個鍵值類型與airports變量聲明的類型相匹配（只有String鍵和只有String值的詞典），因此字典文本的賦值可以用來初始化airports帶有兩個初始化項的字典。
與數組一樣，如果使用鍵和值具有一致類型的字典文字進行初始化，則不必編寫字典的類型。初始化airports本來可以用較短的形式寫成：
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
由于文本中的所有鍵都是彼此相同的類型，并且同樣所有的值都是相同類型的，所以Swift可以推斷出這[String: String]是用于airports字典的正確類型。
訪問和修改字典
您可以通過其方法和屬性或使用下標語法來訪問和修改字典。
與數組一樣，您可以Dictionary通過檢查其只讀count屬性來找出a中的項目數量：
print("The airports dictionary contains \(airports.count) items.")// Prints "The airports dictionary contains 2 items."
使用Boolean isEmpty屬性作為檢查count屬性是否等于的快捷方式0：
if airports.isEmpty {print("The airports dictionary is empty.")} else {print("The airports dictionary is not empty.")}// Prints "The airports dictionary is not empty."
您可以使用下標語法將新項目添加到字典中。使用適當類型的新鍵作為下標索引，并分配適當類型的新值：
airports["LHR"] = "London"// the airports dictionary now contains 3 items
您還可以使用下標語法來更改與特定鍵關聯的值：
airports["LHR"] = "London Heathrow"// the value for "LHR" has been changed to "London Heathrow"
作為下標的替代updateValue(_:forKey:)方法，使用字典的方法來設置或更新特定鍵的值。就像上面的下標示例一樣，updateValue(_:forKey:)如果某個鍵不存在，該方法將為該鍵設置一個值，如果該鍵已經存在，該方法將更新該值。然而，與下標不同的是，該updateValue(_:forKey:)方法在執行更新后返回舊值。這使您可以檢查是否發生更新。
該updateValue(_:forKey:)方法返回字典值類型的可選值。例如，對于存儲String值的字典，該方法返回一個類型值String?，或“可選String”。如果更新前存在該值，則此可選值包含該值的舊值，或者nil沒有值：
if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {print("The old value for DUB was \(oldValue).")}// Prints "The old value for DUB was Dublin."
您還可以使用下標語法從字典中檢索特定鍵的值。因為可以請求不存在值的鍵，所以字典的下標返回字典值類型的可選值。如果字典包含請求鍵的值，則下標返回包含該鍵現有值的可選值。否則，下標返回nil：
if let airportName = airports["DUB"] {print("The name of the airport is \(airportName).")} else {print("That airport is not in the airports dictionary.")}// Prints "The name of the airport is Dublin Airport."
您可以使用下標語法通過指定該鍵的值來從字典中刪除鍵值對nil：
airports["APL"] = "Apple International"// "Apple International" is not the real airport for APL, so delete itairports["APL"] = nil// APL has now been removed from the dictionary
或者，使用該removeValue(forKey:)方法從字典中移除鍵值對。如果鍵值對存在并返回已除去的值，則該方法將移除鍵值對，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.")}// Prints "The removed airport's name is Dublin Airport."
迭代字典
您可以用字典遍歷鍵值對for- in環。字典中的每一項都作為(key, value)元組返回，并且可以將元組的成員分解為臨時常量或變量，作為迭代的一部分：
for (airportCode, airportName) in airports {print("\(airportCode): \(airportName)")}// YYZ: Toronto Pearson// LHR: London Heathrow
有關for- in循環的更多信息，請參閱For-In循環。
您還可以通過訪問其屬性keys和values屬性來檢索字典鍵或值的可迭代集合：
for airportCode in airports.keys {print("Airport code: \(airportCode)")}// Airport code: YYZ// Airport code: LHRfor airportName in airports.values {print("Airport name: \(airportName)")}// Airport name: Toronto Pearson// Airport name: London Heathrow
如果您需要使用帶有Array實例的API的字典鍵或值，請使用keys或values屬性初始化新數組：
let airportCodes = [String](airports.keys)// airportCodes is ["YYZ", "LHR"]let airportNames = [String](airports.values)// airportNames is ["Toronto Pearson", "London Heathrow"]
Swift的Dictionary類型沒有定義的順序。要按特定順序遍歷字典的鍵或值，請sorted()在其keys或values屬性上使用該方法。
