本章將會介紹

數(shù)組類型（Arrays）
集合類型（Sets）
字典（Dictionaries）
控制流

數(shù)組類型（Arrays）

Swift 語言提供Arrays坟岔、Sets和Dictionaries三種基本的集合類型用來存儲集合數(shù)據(jù)摔桦。數(shù)組（Arrays）是有序數(shù)據(jù)的集。集合（Sets）是無序無重復(fù)數(shù)據(jù)的集鸥咖。字典（Dictionaries）是無序的鍵值對的集。

圖片地址

Swift 語言中的Arrays啊研、Sets和Dictionaries中存儲的數(shù)據(jù)值類型必須明確熙兔。這意味著我們不能把不正確的數(shù)據(jù)類型插入其中艾恼。同時這也說明我們完全可以對取回值的類型非常自信钠绍。

注意：
Swift 的Arrays、Sets和Dictionaries類型被實現(xiàn)為泛型集合柳爽。更多關(guān)于泛型類型和集合

1.集合的可變性

如果創(chuàng)建一個Arrays、Sets或Dictionaries并且把它分配成一個變量蛾找，這個集合將會是可變的赵誓。這意味著我們可以在創(chuàng)建之后添加更多或移除已存在的數(shù)據(jù)項，或者改變集合中的數(shù)據(jù)項幻枉。如果我們把Arrays诡蜓、Sets或Dictionaries分配成常量，那么它就是不可變的椿肩，它的大小和內(nèi)容都不能被改變豺谈。

注意：
在我們不需要改變集合的時候創(chuàng)建不可變集合是很好的實踐。如此 Swift 編譯器可以優(yōu)化我們創(chuàng)建的集合扣唱。

2.數(shù)組(Arrays)

數(shù)組使用有序列表存儲同一類型的多個值。相同的值可以多次出現(xiàn)在一個數(shù)組的不同位置中炼彪。Swift 的Array類型被橋接到Foundation中的NSArray類。

• 數(shù)組的簡單語法

  • 寫 Swift 數(shù)組應(yīng)該遵循像Array<Element>這樣的形式正歼，其中Element是這個數(shù)組中唯一允許存在的數(shù)據(jù)類型辐马。我們也可以使用像[Element]這樣的簡單語法。盡管兩種形式在功能上是一樣的局义，但是推薦較短的那種喜爷。

• 創(chuàng)建一個空數(shù)組

  • 我們可以使用構(gòu)造語法來創(chuàng)建一個由特定數(shù)據(jù)類型構(gòu)成的空數(shù)組：

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

注意，通過構(gòu)造函數(shù)的類型萄唇，someInts的值類型被推斷為[Int]檩帐。
或者，如果代碼上下文中已經(jīng)提供了類型信息另萤，例如一個函數(shù)參數(shù)或者一個已經(jīng)定義好類型的常量或者變量湃密，我們可以使用空數(shù)組語句創(chuàng)建一個空數(shù)組，它的寫法很簡單：[]（一對空方括號）：

someInts.append(3)
// someInts 現(xiàn)在包含一個 Int 值
someInts = []
// someInts 現(xiàn)在是空數(shù)組泛源，但是仍然是 [Int] 類型的。

• 創(chuàng)建一個帶有默認值的數(shù)組
  • Swift 中的Array類型還提供一個可以創(chuàng)建特定大小并且所有數(shù)據(jù)都被默認的構(gòu)造方法忿危。我們可以把準(zhǔn)備加入新數(shù)組的數(shù)據(jù)項數(shù)量（count）和適當(dāng)類型的初始值（repeating）傳入數(shù)組構(gòu)造函數(shù)：

var threeDoubles = Array(repeatElement(0.0, count: 3))
// threeDoubles 是一種 [Double] 數(shù)組达箍，等價于 [0.0, 0.0, 0.0]

• 通過兩個數(shù)組相加創(chuàng)建一個數(shù)組
  • 我們可以使用加法操作符（+）來組合兩種已存在的相同類型數(shù)組。新數(shù)組的數(shù)據(jù)類型會被從兩個數(shù)組的數(shù)據(jù)類型中推斷出來：

var someInts = [Int]()
someInts.append(3)

var streeDoubles = Array(repeatElement(4, count: 3))
var six = someInts + streeDoubles
// [3, 4, 4, 4]

• 用數(shù)組字面量構(gòu)造數(shù)組
  • 我們可以使用數(shù)組字面量來進行數(shù)組構(gòu)造铺厨，這是一種用一個或者多個數(shù)值構(gòu)造數(shù)組的簡單方法缎玫。數(shù)組字面量是一系列由逗號分割并由方括號包含的數(shù)值：[value 1, value 2, value 3]。
  • 下面這個例子創(chuàng)建了一個叫做shoppingList并且存儲String的數(shù)組：

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已經(jīng)被構(gòu)造并且擁有兩個初始項努释。

shoppingList變量被聲明為“字符串值類型的數(shù)組“碘梢，記作[String]。 因為這個數(shù)組被規(guī)定只有String一種數(shù)據(jù)結(jié)構(gòu)伐蒂，所以只有String類型可以在其中被存取煞躬。 在這里，shoppingList數(shù)組由兩個String值（"Eggs" 和"Milk"）構(gòu)造逸邦，并且由數(shù)組字面量定義恩沛。

在這個例子中，字面量僅僅包含兩個String值缕减。匹配了該數(shù)組的變量聲明（只能包含String的數(shù)組）雷客，所以這個字面量的分配過程可以作為用兩個初始項來構(gòu)造shoppingList的一種方式。

由于 Swift 的類型推斷機制桥狡，當(dāng)我們用字面量構(gòu)造只擁有相同類型值數(shù)組的時候搅裙，我們不必把數(shù)組的類型定義清楚皱卓。 shoppingList的構(gòu)造也可以這樣寫：

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

因為所有數(shù)組字面量中的值都是相同的類型，Swift 可以推斷出[String]是shoppingList中變量的正確類型部逮。

• 訪問和修改數(shù)組
  • 我們可以通過數(shù)組的方法和屬性來訪問和修改數(shù)組娜汁，或者使用下標(biāo)語法。
• 可以使用數(shù)組的只讀屬性count來獲取數(shù)組中的數(shù)據(jù)項數(shù)量：

print("The shopping list contains \(shoppingList.count) items.")
// 輸出 "The shopping list contains 2 items."（這個數(shù)組有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(_:)方法在數(shù)組后面添加新的數(shù)據(jù)項：

shoppingList.append("Flour")
// shoppingList 現(xiàn)在有3個數(shù)據(jù)項兄朋，

• 除此之外诀黍，使用加法賦值運算符（+=）也可以直接在數(shù)組后面添加一個或多個擁有相同類型的數(shù)據(jù)項：

shoppingList += ["Baking Powder"]
// shoppingList 現(xiàn)在有四項了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 現(xiàn)在有七項了

• 可以直接使用下標(biāo)語法來獲取數(shù)組中的數(shù)據(jù)項焙格，把我們需要的數(shù)據(jù)項的索引值放在直接放在數(shù)組名稱的方括號中：

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

• 我們也可以用下標(biāo)來改變某個已有索引值對應(yīng)的數(shù)據(jù)值：

shoppingList[0] = "Six eggs"
// 其中的第一項現(xiàn)在是 "Six eggs" 而不是 "Eggs"

• 還可以利用下標(biāo)來一次改變一系列數(shù)據(jù)值，即使新數(shù)據(jù)和原有數(shù)據(jù)的數(shù)量是不一樣的壕吹。下面的例子把"Chocolate Spread"翅娶，"Cheese"蝶押，和"Butter"替換為"Bananas"和 "Apples"：

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 現(xiàn)在有6項

• 調(diào)用數(shù)組的insert(_:at:)方法來在某個具體索引值之前添加數(shù)據(jù)項：

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList 現(xiàn)在有7項
// "Maple Syrup" 現(xiàn)在是這個列表中的第一項

這次insert(_:at:)方法調(diào)用把值為"Maple Syrup"的新數(shù)據(jù)項插入列表的最開始位置昼激，并且使用0作為索引值拖陆。

• 類似的我們可以使用remove(at:)方法來移除數(shù)組中的某一項。這個方法把數(shù)組在特定索引值中存儲的數(shù)據(jù)項移除并且返回這個被移除的數(shù)據(jù)項（我們不需要的時候就可以無視它）：

let mapleSyrup = shoppingList.remove(at: 0)
// 索引值為0的數(shù)據(jù)項被移除
// shoppingList 現(xiàn)在只有6項有额，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除數(shù)據(jù)項的值 "Maple Syrup"

• 如果我們只想把數(shù)組中的最后一項移除般又，可以使用removeLast()方法而不是remove(at:)方法來避免我們需要獲取數(shù)組的count屬性彼绷。就像后者一樣巍佑，前者也會返回被移除的數(shù)據(jù)項：

let apples = shoppingList.removeLast()
// 數(shù)組的最后一項被移除了
// shoppingList 現(xiàn)在只有5項，不包括 Apples
// apples 常量的值現(xiàn)在等于 "Apples" 字符串

3.數(shù)組的遍歷

• 我們可以使用for-in循環(huán)來遍歷所有數(shù)組中的數(shù)據(jù)項：

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

• 如果我們同時需要每個數(shù)據(jù)項的值和索引值寄悯，可以使用enumerated()方法來進行數(shù)組遍歷萤衰。enumerated()返回一個由每一個數(shù)據(jù)項索引值和數(shù)據(jù)值組成的元組。我們可以把這個元組分解成臨時常量或者變量來進行遍歷：

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

4.數(shù)組總結(jié)

// 數(shù)組

// 創(chuàng)建一個空數(shù)組
var someInts = [Int]()
// 通過構(gòu)造函數(shù)的類型猜旬，someInt的值的類型被推斷為[Int]

// 為數(shù)組添加元素
someInts.append(3)

// 數(shù)組制空
someInts = []
// 使用repeat方法添加元素
someInts = Array(repeatElement(3, count: 2))

// 兩個數(shù)組相加
var anotherIntArray = Array(repeatElement(2, count: 3))
// 注意必須保證兩個合并的數(shù)組元素類型一致
var totalAyyay = someInts + anotherIntArray

// 字面量創(chuàng)建數(shù)組
var shoppingList = ["Eggs", "Milk"]
// 根據(jù)類型推斷創(chuàng)建的是[String]類型的數(shù)組 隱式類型

// 獲取數(shù)組元素
shoppingList.count

// 判斷數(shù)組個數(shù)是否為0
shoppingList.isEmpty

// 使用append方法添加元素
shoppingList.append("Flour")

// 使用加法賦值運算符 += 直接在數(shù)組后邊添加一個或多個相同類型的元素
shoppingList += ["Baking Powder"]
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]

// 使用索引獲取數(shù)組元素
shoppingList[0]

// 根據(jù)下表索引修改元素
shoppingList[0] = "Six Eggs"
shoppingList

// 利用下標(biāo)區(qū)間修改多個元素
shoppingList[4...6] = ["Bananas", "Apples"]
shoppingList

// 調(diào)用insert方法在某個位置插入元素
shoppingList.insert("Maple Syrup", at: 0)

// 調(diào)用remove方法移除數(shù)組中的某一項
shoppingList.remove(at: 0)
shoppingList

// 移除最后一項
shoppingList.removeLast()
shoppingList

// 移除第一項
shoppingList.removeFirst()
shoppingList

// 數(shù)組的遍歷
for item in shoppingList {
   print(item)
}

// 遍歷數(shù)組元素和索引
for (index, value) in shoppingList.enumerated() {
    print("Item \(String(index + 1)): \(value)")
}

集合類型（Sets）

集合(Set)用來存儲相同類型并且沒有確定順序的值脆栋。當(dāng)集合元素順序不重要時或者希望確保每個元素只出現(xiàn)一次時可以使用集合而不是數(shù)組。

Swift的Set類型被橋接到Foundation中的NSSet類洒擦。

1.集合類型的哈希值

一個類型為了存儲在集合中椿争，該類型必須是可哈希化的--也就是說熟嫩，該類型必須提供一個方法來計算它的哈希值秦踪。一個哈希值是Int類型的，相等的對象哈希值必須相同掸茅，比如a==b,因此必須a.hashValue == b.hashValue椅邓。

Swift 的所有基本類型(比如String,Int,Double和Bool)默認都是可哈希化的昧狮，可以作為集合的值的類型或者字典的鍵的類型景馁。沒有關(guān)聯(lián)值的枚舉成員值默認也是可哈希化的逗鸣。

注意：
你可以使用你自定義的類型作為集合的值的類型或者是字典的鍵的類型合住，但你需要使你的自定義類型符合 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(傳遞性)

2.集合類型的語法

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

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

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

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

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

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

• 用數(shù)組字面量創(chuàng)建集合
  • 你可以使用數(shù)組字面量來構(gòu)造集合妻往，并且可以使用簡化形式寫一個或者多個值作為集合元素互艾。下面的例子創(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ù)組字面量的方式出現(xiàn)。

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

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

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

3.訪問和修改一個集合

• 你可以通過Set的屬性和方法來訪問和修改一個Set。為了找出一個Set中元素的數(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)用Set的insert(_:)方法來添加一個新元素：

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

• 你可以通過調(diào)用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."

4.遍歷一個集合

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

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

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

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

5.集合操作

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

• 基本集合操作 下面的插圖描述了兩個集合-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彼此不關(guān)聯(lián)础米，因為它們之間沒有共同的元素。
  • 使用“是否相等”運算符(==)來判斷兩個集合是否包含全部相同的值添诉。
  • 使用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

6.集合總結(jié)

// 集合

// 創(chuàng)建和構(gòu)造一個空集合
var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")

// 給集合添加元素
letters.insert("a")
letters

// 清空集合
letters = []
letters

// 用數(shù)組字面量創(chuàng)建集合
var favoriteGenres: Set = ["Rock", "Classical", "Hip Hop"]
// 根據(jù)類型推斷 知道favoriteGenres是Set<String>類型的

// 讀取集合中元素個數(shù)
favoriteGenres.count
// 判斷集合中元素個數(shù)是否是0
favoriteGenres.isEmpty

// 通過insert方法添加元素
favoriteGenres.insert("Jazz")
favoriteGenres

// 通過remove方法刪除集合中一個元素
favoriteGenres.remove("Rock")
favoriteGenres

// 使用contains檢查集合中是否包含特定的值
favoriteGenres.contains("Jazz")

// 遍歷集合
for genre in favoriteGenres {
    print(genre)
}

// 按照特定順序遍歷集合 默認按照“<”操作符進行遍歷
for genre in favoriteGenres.sorted() {
    print(genre)
}

let oddDigits: Set = [1,3,5,7,9]
let evenDigits: Set = [0,2,4,6,8]
let singleDigitPrimeNumbers: Set = [2,3,5,7]
// 兩個集合的交集
oddDigits.intersection(evenDigits).sorted()
// 兩個集合的并集
oddDigits.union(evenDigits).sorted()
// 在一個集合中但不在兩個集合中的值創(chuàng)建一個新的集合
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()

字典（Dictionaries）

字典是一種存儲多個相同類型的值的容器。每個值（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類扩劝。

1.字典類型簡化語法

Swift 的字典使用Dictionary<Key, Value>定義庸论，其中Key是字典中鍵的數(shù)據(jù)類型职辅，Value是字典中對應(yīng)于這些鍵所存儲值的數(shù)據(jù)類型。

注意：
一個字典的Key類型必須遵循Hashable協(xié)議聂示，就像Set的值類型域携。
我們也可以用[Key: Value]這樣簡化的形式去創(chuàng)建一個字典類型。雖然這兩種形式功能上相同鱼喉，但是后者是首選秀鞭。

2.字典

• 創(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集合的快捷途徑灵巧。
  • 一個鍵值對是一個key和一個value的結(jié)合體搀矫。在字典字面量中，每一個鍵值對的鍵和值都由冒號分割刻肄。這些鍵值對構(gòu)成一個列表瓤球，其中這些鍵值對由方括號包含、由逗號分割：

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

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

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

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

airports字典使用字典字面量初始化绿饵，包含兩個鍵值對。第一對的鍵是YYZ瓶颠，值是Toronto Pearson拟赊。第二對的鍵是DUB，值是Dublin粹淋。

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

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

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

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

2.訪問和修改字典

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

• 和數(shù)組一樣缘琅，我們可以通過字典的只讀屬性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 機場, 刪除它
airports["APL"] = nil
// APL 現(xiàn)在被移除了

• 此外，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."

3.字典遍歷

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

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

• 通過訪問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 的字典類型是無序集合類型。為了以特定的順序遍歷字典的鍵或值珊燎，可以對字典的keys或values屬性使用sorted()方法。

3.字典總結(jié)

// 字典

// 創(chuàng)建一個空字典
var nameOfIntegers = [Int: String]()

// 添加元素
nameOfIntegers[16] = "sixteen"
nameOfIntegers

// 清空字典
nameOfIntegers = [:]

// 用字典字面量創(chuàng)建字典
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
// 根據(jù)類型推斷 airports的類型是[String: String]

// 字典元素個數(shù)
airports.count

// 判斷字典元素個數(shù)是否是0
airports.isEmpty

// 使用下標(biāo)語法添加新的元素
airports["LHR"] = "London"
airports

// 使用下標(biāo)語法來更改元素
airports["LHR"] = "London Heathrow"
airports

// updateValue(_:forKey:)方法可以設(shè)置或者更新特定鍵對應(yīng)的值,返回之前的值
airports.updateValue("Dubin Airport", forKey: "DUB")
airports

// 將某個鍵值設(shè)置成nil遵湖，刪除某個元素
airports["DUB"] = nil
airports

// 根據(jù)鍵刪除某個元素
airports.removeValue(forKey: "LHR")
airports

airports["APL"] = "Apple Internation"
airports["LHR"] = "London Heathrow"
airports

// 字典遍歷
for (airportCode, airportName) in airports {
    print("\(airportCode) : \(airportName)")
}

// 遍歷所有的keys
for airportCode in airports.keys.sorted() {
    print(airportCode)
}

// 遍歷所有的values
for airportName in airports.values {
    print(airportName)
}