swift官方推薦翻譯文檔之集合類型

Swift 語言提供Arrays、Sets和Dictionaries三種基本的集合類型用來存儲集合數據。數組（Arrays）是有序數據的集。集合（Sets）是無序無重複數據的集。字典（Dictionaries）是無序的鍵值對的集。

Swift 語言中的Arrays、Sets和Dictionaries中存儲的數據值類型必須明確。這意味着咱們不能把不正確的數據類型插入其中。同時這也說明咱們徹底能夠對取回值的類型很是自信。

注意：
Swift 的Arrays、Sets和Dictionaries類型被實現爲泛型集合。更多關於泛型類型和集合，參見 泛型章節。

集合的可變性

若是建立一個Arrays、Sets或Dictionaries而且把它分配成一個變量，這個集合將會是可變的。這意味着咱們能夠在建立以後添加更多或移除已存在的數據項，或者改變集合中的數據項。若是咱們把Arrays、Sets或Dictionaries分配成常量，那麼它就是不可變的，它的大小和內容都不能被改變。

注意：
在咱們不須要改變集合的時候建立不可變集合是很好的實踐。如此 Swift 編譯器能夠優化咱們建立的集合。

數組(Arrays)

數組使用有序列表存儲同一類型的多個值。相同的值能夠屢次出如今一個數組的不一樣位置中。

注意: Swift 的Array類型被橋接到Foundation中的NSArray類。 更多關於在Foundation和Cocoa中使用Array的信息，參見 Using Swift with Cocoa and Obejective-C 一書。

數組的簡單語法

寫 Swift 數組應該遵循像Array<Element>這樣的形式，其中Element是這個數組中惟一容許存在的數據類型。咱們也可使用像[Element]這樣的簡單語法。儘管兩種形式在功能上是同樣的，可是推薦較短的那種，並且在本文中都會使用這種形式來使用數組。

建立一個空數組

咱們可使用構造語法來建立一個由特定數據類型構成的空數組：

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// 打印 "someInts is of type [Int] with 0 items."

注意，經過構造函數的類型，someInts的值類型被推斷爲[Int]。

或者，若是代碼上下文中已經提供了類型信息，例如一個函數參數或者一個已經定義好類型的常量或者變量，咱們可使用空數組語句建立一個空數組，它的寫法很簡單：[]（一對空方括號）：

someInts.append(3)
// someInts 如今包含一個 Int 值
someInts = []
// someInts 如今是空數組，可是仍然是 [Int] 類型的。

建立一個帶有默認值的數組

Swift 中的Array類型還提供一個能夠建立特定大小而且全部數據都被默認的構造方法。咱們能夠把準備加入新數組的數據項數量（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]

用字面量構造數組

咱們可使用字面量來進行數組構造，這是一種用一個或者多個數值構造數組的簡單方法。字面量是一系列由逗號分割並由方括號包含的數值：

[value 1, value 2, value 3]。

下面這個例子建立了一個叫作shoppingList而且存儲String的數組：

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已經被構造而且擁有兩個初始項。

shoppingList變量被聲明爲「字符串值類型的數組「，記做[String]。 由於這個數組被規定只有String一種數據結構，因此只有String類型能夠在其中被存取。 在這裏，shoppinglist數組由兩個String值（"Eggs" 和"Milk"）構造，而且由字面量定義。

注意：
Shoppinglist數組被聲明爲變量（var關鍵字建立）而不是常量（let建立）是由於之後可能會有更多的數據項被插入其中。

在這個例子中，字面量僅僅包含兩個String值。匹配了該數組的變量聲明（只能包含String的數組），因此這個字面量的分配過程能夠做爲用兩個初始項來構造shoppinglist的一種方式。

因爲 Swift 的類型推斷機制，當咱們用字面量構造只擁有相同類型值數組的時候，咱們沒必要把數組的類型定義清楚。 shoppinglist的構造也能夠這樣寫：

var shoppingList = ["Eggs", "Milk"]

由於全部字面量中的值都是相同的類型，Swift 能夠推斷出[String]是shoppinglist中變量的正確類型。

訪問和修改數組

咱們能夠經過數組的方法和屬性來訪問和修改數組，或者使用下標語法。

可使用數組的只讀屬性count來獲取數組中的數據項數量：

print("The shopping list contains \(shoppingList.count) items.")
// 輸出 "The shopping list contains 2 items."（這個數組有2個項）

使用布爾值屬性isEmpty做爲檢查count屬性的值是否爲 0 的捷徑：

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."（shoppinglist 不是空的）

也可使用append(_:)方法在數組後面添加新的數據項：

shoppingList.append("Flour")
// shoppingList 如今有3個數據項，有人在攤煎餅

除此以外，使用加法賦值運算符（+=）也能夠直接在數組後面添加一個或多個擁有相同類型的數據項：

shoppingList += ["Baking Powder"]
// shoppingList 如今有四項了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 如今有七項了

能夠直接使用下標語法來獲取數組中的數據項，把咱們須要的數據項的索引值放在直接放在數組名稱的方括號中：

var firstItem = shoppingList[0]
// 第一項是 "Eggs"

注意：
第一項在數組中的索引值是0而不是1。 Swift 中的數組索引老是從零開始。

咱們也能夠用下標來改變某個已有索引值對應的數據值：

shoppingList[0] = "Six eggs"
// 其中的第一項如今是 "Six eggs" 而不是 "Eggs"

還能夠利用下標來一次改變一系列數據值，即便新數據和原有數據的數量是不同的。下面的例子把"Chocolate Spread"，"Cheese"，和"Butter"替換爲"Bananas"和 "Apples"：

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 如今有6項

注意：
不能夠用下標訪問的形式去在數組尾部添加新項。

調用數組的insert(_:atIndex:)方法來在某個具體索引值以前添加數據項：

shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 如今有7項
// "Maple Syrup" 如今是這個列表中的第一項

此次insert(_:atIndex:)方法調用把值爲"Maple Syrup"的新數據項插入列表的最開始位置，而且使用0做爲索引值。

相似的咱們可使用removeAtIndex(_:)方法來移除數組中的某一項。這個方法把數組在特定索引值中存儲的數據項移除而且返回這個被移除的數據項（咱們不須要的時候就能夠無視它）：

let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值爲0的數據項被移除
// shoppingList 如今只有6項，並且不包括 Maple Syrup
// mapleSyrup 常量的值等於被移除數據項的值 "Maple Syrup"

注意：
若是咱們試着對索引越界的數據進行檢索或者設置新值的操做，會引起一個運行期錯誤。咱們可使用索引值和數組的count屬性進行比較來在使用某個索引以前先檢驗是否有效。除了當count等於 0 時（說明這是個空數組），最大索引值一直是count - 1，由於數組都是零起索引。

數據項被移除後數組中的空出項會被自動填補，因此如今索引值爲0的數據項的值再次等於"Six eggs"：

firstItem = shoppingList[0]
// firstItem 如今等於 "Six eggs"

若是咱們只想把數組中的最後一項移除，可使用removeLast()方法而不是removeAtIndex(_:)方法來避免咱們須要獲取數組的count屬性。就像後者同樣，前者也會返回被移除的數據項：

let apples = shoppingList.removeLast()
// 數組的最後一項被移除了
// shoppingList 如今只有5項，不包括 Apples
// apples 常量的值如今等於 "Apples" 字符串

數組的遍歷

咱們可使用for-in循環來遍歷全部數組中的數據項：

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

若是咱們同時須要每一個數據項的值和索引值，可使用enumerate()方法來進行數組遍歷。enumerate()返回一個由每個數據項索引值和數據值組成的元組。咱們能夠把這個元組分解成臨時常量或者變量來進行遍歷：

for (index, value) in shoppingList.enumerate() {
    print("Item \(String(index + 1)): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

更多關於for-in循環的介紹請參見for 循環。

集合（Sets）

集合(Set)用來存儲相同類型而且沒有肯定順序的值。當集合元素順序不重要時或者但願確保每一個元素只出現一次時可使用集合而不是數組。

注意：
Swift的Set類型被橋接到Foundation中的NSSet類。
關於使用Foundation和Cocoa中Set的知識，請看 Using Swift with Cocoa and Objective-C。

集合類型的哈希值

一個類型爲了存儲在集合中，該類型必須是可哈希化的--也就是說，該類型必須提供一個方法來計算它的哈希值。一個哈希值是Int類型的，相等的對象哈希值必須相同，好比a==b,所以必須a.hashValue == b.hashValue。

Swift 的全部基本類型(好比String,Int,Double和Bool)默認都是可哈希化的，能夠做爲集合的值的類型或者字典的鍵的類型。沒有關聯值的枚舉成員值(在枚舉有講述)默認也是可哈希化的。

注意：
你可使用你自定義的類型做爲集合的值的類型或者是字典的鍵的類型，但你須要使你的自定義類型符合 Swift 標準庫中的Hashable協議。符合Hashable協議的類型須要提供一個類型爲Int的可讀屬性hashValue。由類型的hashValue屬性返回的值不須要在同一程序的不一樣執行週期或者不一樣程序之間保持相同。

由於Hashable協議符合Equatable協議，因此符合該協議的類型也必須提供一個"是否相等"運算符(==)的實現。這個Equatable協議要求任何符合==實現的實例間都是一種相等的關係。也就是說，對於a,b,c三個值來講，==的實現必須知足下面三種狀況：

• a == a(自反性)

• a == b意味着b == a(對稱性)

• a == b && b == c意味着a == c(傳遞性)

關於符合協議的更多信息，請看協議。

集合類型語法

Swift 中的Set類型被寫爲Set<Element>，這裏的Element表示Set中容許存儲的類型，和數組不一樣的是，集合沒有等價的簡化形式。

建立和構造一個空的集合

你能夠經過構造器語法建立一個特定類型的空集合：

var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
// 打印 "letters is of type Set<Character> with 0 items."

注意：
經過構造器，這裏的letters變量的類型被推斷爲Set<Character>。

此外，若是上下文提供了類型信息，好比做爲函數的參數或者已知類型的變量或常量，咱們能夠經過一個空的數組字面量建立一個空的Set：

letters.insert("a")
// letters 如今含有1個 Character 類型的值
letters = []
// letters 如今是一個空的 Set, 可是它依然是 Set<Character> 類型

用數組字面量建立集合

你可使用數組字面量來構造集合，而且可使用簡化形式寫一個或者多個值做爲集合元素。

下面的例子建立一個稱之爲favoriteGenres的集合來存儲String類型的值：

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

這個favoriteGenres變量被聲明爲「一個String值的集合」，寫爲Set<String>。因爲這個特定的集合含有指定String類型的值，因此它只容許存儲String類型值。這裏的favoriteGenres變量有三個String類型的初始值("Rock"，"Classical"和"Hip hop")，並以數組字面量的方式出現。

注意：
favoriteGenres被聲明爲一個變量(擁有var標示符)而不是一個常量(擁有let標示符),由於它裏面的元素將會在下面的例子中被增長或者移除。

一個Set類型不能從數組字面量中被單獨推斷出來，所以Set類型必須顯式聲明。然而，因爲 Swift 的類型推斷功能，若是你想使用一個數組字面量構造一個Set而且該數組字面量中的全部元素類型相同，那麼你無須寫出Set的具體類型。favoriteGenres的構造形式能夠採用簡化的方式代替：

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

因爲數組字面量中的全部元素類型相同，Swift 能夠推斷出Set<String>做爲favoriteGenres變量的正確類型。

訪問和修改一個集合

你能夠經過Set的屬性和方法來訪問和修改一個Set。

爲了找出一個Set中元素的數量，可使用其只讀屬性count：

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

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."

你能夠經過調用Set的insert(_:)方法來添加一個新元素：

favoriteGenres.insert("Jazz")
// favoriteGenres 如今包含4個元素

你能夠經過調用Set的remove(_:)方法去刪除一個元素，若是該值是該Set的一個元素則刪除該元素而且返回被刪除的元素值，不然若是該Set不包含該值，則返回nil。另外，Set中的全部元素能夠經過它的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(_:)方法去檢查Set中是否包含一個特定的值：

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循環中遍歷一個Set中的全部值。

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

Swift 的Set類型沒有肯定的順序，爲了按照特定順序來遍歷一個Set中的值可使用sort()方法，它將根據提供的序列返回一個有序集合.

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

集合操做

你能夠高效地完成Set的一些基本操做，好比把兩個集合組合到一塊兒，判斷兩個集合共有元素，或者判斷兩個集合是否全包含，部分包含或者不相交。

基本集合操做

下面的插圖描述了兩個集合-a和b-以及經過陰影部分的區域顯示集合各類操做的結果。

• 使用intersect(_:)方法根據兩個集合中都包含的值建立的一個新的集合。

• 使用exclusiveOr(_:)方法根據在一個集合中但不在兩個集合中的值建立一個新的集合。

• 使用union(_:)方法根據兩個集合的值建立一個新的集合。

• 使用subtract(_:)方法根據不在該集合中的值建立一個新的集合。

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).sort()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersect(evenDigits).sort()
// []
oddDigits.subtract(singleDigitPrimeNumbers).sort()
// [1, 9]
oddDigits.exclusiveOr(singleDigitPrimeNumbers).sort()
// [1, 2, 9]

集合成員關係和相等

下面的插圖描述了三個集合-a,b和c,以及經過重疊區域表述集合間共享的元素。集合a是集合b的父集合，由於a包含了b中全部的元素，相反的，集合b是集合a的子集合，由於屬於b的元素也被a包含。集合b和集合c彼此不關聯，由於它們之間沒有共同的元素。

• 使用「是否相等」運算符(==)來判斷兩個集合是否包含所有相同的值。

• 使用isSubsetOf(_:)方法來判斷一個集合中的值是否也被包含在另一個集合中。

• 使用isSupersetOf(_:)方法來判斷一個集合中包含另外一個集合中全部的值。

• 使用isStrictSubsetOf(_:)或者isStrictSupersetOf(_:)方法來判斷一個集合是不是另一個集合的子集合或者父集合而且兩個集合並不相等。

• 使用isDisjointWith(_:)方法來判斷兩個集合是否不含有相同的值(是否沒有交集)。

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubsetOf(farmAnimals)
// true
farmAnimals.isSupersetOf(houseAnimals)
// true
farmAnimals.isDisjointWith(cityAnimals)

字典

字典是一種存儲多個相同類型的值的容器。每一個值（value）都關聯惟一的鍵（key），鍵做爲字典中的這個值數據的標識符。和 數組中的數據項不一樣，字典中的數據項並無具體順序。咱們在須要經過標識符（鍵）訪問數據的時候使用字典，這種方法很大程度上和咱們在現實世界中使用字典 查字義的方法同樣。

注意：
Swift 的Dictionary類型被橋接到Foundation的NSDictionary類。
更多關於在Foundation和Cocoa中使用Dictionary類型的信息，參見 Using Swift with Cocoa and Objective-C (Swift 2.1) 一書。

字典類型快捷語法

Swift 的字典使用Dictionary<Key, Value>定義，其中Key是字典中鍵的數據類型，Value是字典中對應於這些鍵所存儲值的數據類型。

注意：
一個字典的Key類型必須遵循Hashable協議，就像Set的值類型。

咱們也能夠用[Key: Value]這樣快捷的形式去建立一個字典類型。雖然這兩種形式功能上相同，可是後者是首選，而且這本指導書涉及到字典類型時通篇採用後者。

建立一個空字典

咱們能夠像數組同樣使用構造語法建立一個擁有肯定類型的空字典

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

這個例子建立了一個[Int: String]類型的空字典來儲存整數的英語命名。它的鍵是Int型，值是String型。

若是上下文已經提供了類型信息，咱們可使用空字典字面量來建立一個空字典，記做[:]（中括號中放一個冒號）：

namesOfIntegers[16] = "sixteen"
// namesOfIntegers 如今包含一個鍵值對
namesOfIntegers = [:]
// namesOfIntegers 又成爲了一個 [Int: String] 類型的空字典

用字典字面量建立字典

咱們可使用字典字面量來構造字典，這和咱們剛纔介紹過的數組字面量擁有類似語法。字典字面量是一種將一個或多個鍵值對寫做Dictionary集合的快捷途徑。

一個鍵值對是一個key和一個value的結合體。在字典字面量中，每個鍵值對的鍵和值都由冒號分割。這些鍵值對構成一個列表，其中這些鍵值對由方括號包含、由逗號分割：

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

下面的例子建立了一個存儲國際機場名稱的字典。在這個字典中鍵是三個字母的國際航空運輸相關代碼，值是機場名稱：

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

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

注意：
airports字典被聲明爲變量（用var關鍵字）而不是常量（let關鍵字）由於後來更多的機場信息會被添加到這個示例字典中。

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

這個字典語句包含了兩個String: String類型的鍵值對。它們對應airports變量聲明的類型（一個只有String鍵和String值的字典）因此這個字典字面量的任務是構造擁有兩個初始數據項的airport字典。

和數組同樣，咱們在用字典字面量構造字典時，若是它的鍵和值都有各自一致的類型，那麼就沒必要寫出字典的類型。airports字典也能夠用這種簡短方式定義：

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

由於這個語句中全部的鍵和值都各自擁有相同的數據類型，Swift 能夠推斷出Dictionary<String, String>是airports字典的正確類型。

訪問和修改字典

咱們能夠經過字典的方法和屬性來訪問和修改字典，或者經過使用下標語法。

和數組同樣，咱們能夠經過字典的只讀屬性count來獲取某個字典的數據項數量：

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

使用布爾屬性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."

咱們也能夠在字典中使用下標語法來添加新的數據項。可使用一個恰當類型的鍵做爲下標索引，而且分配恰當類型的新值：

airports["LHR"] = "London"
// airports 字典如今有三個數據項

咱們也可使用下標語法來改變特定鍵對應的值：

airports["LHR"] = "London Heathrow"
// "LHR"對應的值 被改成 "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).")
}
// 輸出 "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.")
}
// 打印 "The name of the airport is Dublin Airport."

咱們還可使用下標語法來經過給某個鍵的對應值賦值爲nil來從字典裏移除一個鍵值對：

airports["APL"] = "Apple Internation"
// "Apple Internation" 不是真的 APL 機場, 刪除它
airports["APL"] = nil
// APL 如今被移除了

此外，removeValueForKey(_:)方法也能夠用來在字典中移除鍵值對。這個方法在鍵值對存在的狀況下會移除該鍵值對而且返回被移除的值或者在沒有值的狀況下返回nil：

if let removedValue = airports.removeValueForKey("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 循環。

經過訪問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 的參數，能夠直接使用keys或者values屬性構造一個新數組：

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

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

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