1.0 翻譯：zqp 校對：shinyzhu, stanzhai, feiin

2.0 翻譯+校對：JackAlan

2.1 校對：shanks

2.2 校對：SketchK 2016-05-11

3.0 校對：shanks ，2016-10-09 3.0.1，shanks，2016-11-12

4.1 翻譯+校對：mylittleswift

本頁包含內容：

• 集合的可變性
• 數(shù)組
  • 創(chuàng)建一個空數(shù)組
  • 創(chuàng)建一個帶有默認值的數(shù)組
  • 通過兩個數(shù)組相加創(chuàng)建一個數(shù)組
  • 用數(shù)組字面量構造數(shù)組
  • 訪問和修改數(shù)組
  • 數(shù)組的遍歷
• 集合
  • 集合類型的哈希值
  • 集合類型語法
  • 創(chuàng)建和構造一個空的集合
  • 用數(shù)組字面量創(chuàng)建集合
  • 訪問和修改一個集合
  • 遍歷一個集合
• 集合操作
  • 基本集合操作
  • 集合成員關系和相等
• 字典
  • 字典類型簡化語法
  • 創(chuàng)建一個空字典
  • 用字典字面量創(chuàng)建字典
  • 訪問和修改字典
  • 字典遍歷

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

Swift 語言中的 Arrays、Sets 和 Dictionaries 中存儲的數(shù)據(jù)值類型必須明確。這意味著我們不能把錯誤的數(shù)據(jù)類型插入其中。同時這也說明你完全可以對取回值的類型非常放心。

注意

Swift 的 Arrays、Sets 和 Dictionaries 類型被實現(xiàn)為泛型集合。更多關于泛型類型和集合，參見 泛型章節(jié)。

集合的可變性

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

注意

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

數(shù)組（Arrays）

數(shù)組使用有序列表存儲同一類型的多個值。相同的值可以多次出現(xiàn)在一個數(shù)組的不同位置中。

注意

Swift 的 Array 類型被橋接到 Foundation 中的 NSArray 類。更多關于在 Foundation 和 Cocoa 中使用 Array 的信息，參見 Using Swift with Cocoa and Obejective-C(Swift 4.1) 中使用 Cocoa 數(shù)據(jù)類型部分。

數(shù)組的簡單語法

寫 Swift 數(shù)組應該遵循像 Array<Element> 這樣的形式，其中 Element 是這個數(shù)組中唯一允許存在的數(shù)據(jù)類型。我們也可以使用像 [Element] 這樣的簡單語法。盡管兩種形式在功能上是一樣的，但是推薦較短的那種，而且在本文中都會使用這種形式來使用數(shù)組。

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

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

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

注意，通過構造函數(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ù)都被默認的構造方法。我們可以把準備加入新數(shù)組的數(shù)據(jù)項數(shù)量（count）和適當類型的初始值（repeating）傳入數(shù)組構造函數(shù)：

var threeDoubles = Array(repeating: 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 anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// 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]

用數(shù)組字面量構造數(shù)組

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

[value 1, value 2, value 3]。

下面這個例子創(chuàng)建了一個叫做 shoppingList 并且存儲 String 的數(shù)組：

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

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

注意

shoppingList 數(shù)組被聲明為變量（var 關鍵字創(chuàng)建）而不是常量（let 創(chuàng)建）是因為以后可能會有更多的數(shù)據(jù)項被插入其中。

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

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

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

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

訪問和修改數(shù)組

我們可以通過數(shù)組的方法和屬性來訪問和修改數(shù)組，或者使用下標語法。

可以使用數(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)在有七項了

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

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

注意

第一項在數(shù)組中的索引值是 0 而不是 1。 Swift 中的數(shù)組索引總是從零開始。

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

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

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

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

注意

不可以用下標訪問的形式去在數(shù)組尾部添加新項。

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

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

這次 insert(_:at:) 方法調用把值為 "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ù)據(jù)進行檢索或者設置新值的操作，會引發(fā)一個運行期錯誤。我們可以使用索引值和數(shù)組的 count 屬性進行比較來在使用某個索引之前先檢驗是否有效。除了當 count 等于 0 時（說明這是個空數(shù)組），最大索引值一直是 count - 1，因為數(shù)組都是零起索引。

數(shù)據(jù)項被移除后數(shù)組中的空出項會被自動填補，所以現(xiàn)在索引值為 0 的數(shù)據(jù)項的值再次等于 "Six eggs"：

firstItem = shoppingList[0]
// firstItem 現(xiàn)在等于 "Six eggs"

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

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

數(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

更多關于 for-in 循環(huán)的介紹請參見for 循環(huán)。

集合（Sets）

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

注意 Swift 的 Set 類型被橋接到 Foundation 中的 NSSet 類。

關于使用 Foundation 和 Cocoa 中 Set 的知識，參見 Using Swift with Cocoa and Obejective-C(Swift 4.1) 中使用 Cocoa 數(shù)據(jù)類型部分。

集合類型的哈希值

一個類型為了存儲在集合中，該類型必須是可哈?；?/em>的--也就是說，該類型必須提供一個方法來計算它的哈希值。一個哈希值是 Int 類型的，相等的對象哈希值必須相同，比如 a==b,因此必須 a.hashValue == b.hashValue。

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

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

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

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

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

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

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

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 genre in favoriteGenres {
    print("\(genre)")
}
// Classical
// Jazz
// Hip hop

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

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]

let houseAnimals: Set = ["