集合类型
Swift提供了三种主要的集合类型，称为数组，集合和字典，用于存储值的集合。 数组是有序的值集合。 set 是唯一值的无序集合。 字典是键值关联的无序集合。
Swift中的数组，集合和字典总是清楚它们可以存储的值和键的类型。这意味着您不能错误地将错误类型的值插入到集合中。这也意味着您可以确信您将从集合中检索的值的类型。
注意
Swift的数组，集合和字典类型被实现为通用集合。有关泛型类型和集合的更多信息，请参阅泛型。
集合的可变性
如果您创建数组，集合或字典，并将其分配给一个变量，则创建的集合将是可变的。这意味着您可以通过添加，删除或更改集合中的项目来更改（或变更）该集合。如果将数组，集合或字典分配给常量，那么该集合是不可变的，并且其大小和内容不能更改。
注意
在集合不需要改变的所有情况下创建不可变集合是一个好习惯。这样做可以让您更轻松地推理代码，并使Swift编译器能够优化您创建的集合的性能。
Array
数组将相同类型的值存储在有序列表中。相同的值可以在不同位置多次出现在阵列中。
注意
Swift的数组类型被桥接到Foundation的NSArray类。
有关在Foundation和Cocoa中使用Array的更多信息，请参阅在Cocoa和Objective-C中使用Swift使用Cocoa数据类型（Swift 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 Int
someInts = []
// someInts is now an empty array, but is still of type [Int]
用默认值创建一个数组
Swift的数组类型还提供了一个初始化器，用于创建一个特定大小的数组，并将其所有值设置为相同的默认值。 您将此初始化程序传递给适当类型（called 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]
用数组字面值创建数组
您还可以使用数组文本初始化数组，这是将一个或多个值作为数组集合写入的简写方法。 数组文字被写为一列值，用逗号分隔，并由一对方括号包围：
[value 1, value 2, value 3]
下面的例子创建一个名为shoppingList的数组来存储String值：
var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items
shoppingList变量被声明为“字符串值数组”，写成[String]。因为这个特定的数组已经指定了一个String类型的值类型，所以它只允许存储String值。这里，shoppingList数组使用两个字符串值（“Eggs”和“Milk”）进行初始化，写入数组文字中。
注意
shoppingList数组被声明为一个变量（使用var introducer）而不是一个常量（使用let introducer），因为在下面的例子中将更多的项目添加到购物列表中。
在这种情况下，数组文字包含两个字符串值，没有别的。这与shoppingList变量的声明（一个只能包含String值的数组）的类型相匹配，因此允许使用数组文本的赋值作为用两个初始项初始化shoppingList的方法。
感谢Swift的类型推断，如果使用包含相同类型值的数组字面值初始化数组，则不必编写数组的类型。 shoppingList的初始化可以用较短的形式写成：
var shoppingList = ["Eggs", "Milk"]
因为数组文本中的所有值都是相同的类型，所以Swift可以推断[String]是用于shoppingList变量的正确类型。
访问和修改数组
您可以通过其方法和属性或使用下标语法来访问和修改数组。
要找出数组中项目的数量，请检查其只读计数属性：
print("The shopping list contains \(shoppingList.count) items.")
// Prints "The shopping list contains 2 items."
使用布尔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 items
shoppingList += ["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”以尝试将项添加到数组的末尾会导致运行时错误。
即使替换值的长度与要替换的范围不同，您也可以使用下标语法一次更改一系列值。 下面的例子用“香蕉”和“苹果”代替“巧克力酱”，“奶酪”和“黄油”：
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
对插入（_：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，因为数组从0开始索引 - 但是，当count为0（意味着数组为空）时，没有有效的索引。
当一个项目被移除时，数组中的任何间隙都会关闭，因此索引0处的值再次等于“六个蛋”：
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循环。
Sets
一个集合在同一个集合中存储相同类型的不同值并且没有定义的顺序。当项目顺序不重要时，或者需要确保项目只出现一次时，您可以使用一组而不是一个数组。
注意
Swift的Set类型被桥接到Foundation的NSSet类。
有关使用Set with Foundation和Cocoa的更多信息，请参阅在Cocoa和Objective-C中使用Swift使用Cocoa数据类型（Swift 4.1）。
集合类型的哈希值(Hash Values for Set Types)
一个类型必须是可散列的才能存储在一个集合中 - 也就是说，该类型必须提供一种为自己计算散列值的方法。散列值是一个Int值，对于所有比较相同的对象都是相同的，例如，如果a == b，则它遵循a.hashValue == b.hashValue。
Swift的所有基本类型（比如String，Int，Double和Bool）默认都是可散列的，并且可以用作设置值类型或字典密钥类型。没有关联值的枚举大小写值（如枚举中所述）默认情况下也是可哈希的。
注意
您可以使用自己的自定义类型作为设置值类型或字典密钥类型，使其符合Swift标准库中的Hashable协议。符合Hashable协议的类型必须提供一个名为hashValue的gettable Int属性。由类型的hashValue属性返回的值不需要在同一程序的不同执行过程中或在不同的程序中相同。
由于Hashable协议符合Equatable，所以符合类型还必须提供equals运算符（==）的实现。 Equatable协议要求==的任何符合实现是等价关系。也就是说，对于所有值a，b和c，==的实现必须满足以下三个条件：
a == a（反思性）
a == b意味着b == a（对称）
a == b && b == c意味着一个== 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."
注意
根据初始值设定项的类型，字母变量的类型被推断为Set <Character>。
或者，如果上下文已经提供了类型信息，例如函数参数或已经存在类型的变量或常量，则可以使用空数组文本创建一个空集：
letters.insert("a")
// letters now contains 1 value of type Character
letters = []
// 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变量被声明为“一组字符串值”，写为Set <String>。 因为这个特定的集合已经指定了一个String类型的值类型，所以只允许存储String值。 在这里，favoriteGenres集合用三个字符串值（“Rock”，“Classical”和“Hip Hop”）初始化，写在一个数组文字中。
注意
favoriteGenres集被声明为变量（使用var introducer）而不是常量（使用let introducer），因为在下面的示例中添加和删除了项目。
集合类型不能单独从数组文本中推断出来，因此必须显式声明Set类型。 但是，由于Swift的类型推断，如果使用包含相同类型值的数组字面值初始化它，则不必编写该类型的集合。 favoriteGenres的初始化本来可以用更简短的形式写成：
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop”]
因为数组文本中的所有值都是相同类型的，所以Swift可以推断出Set <String>是用于favoriteGenres变量的正确类型。
访问和修改集合
你可以通过它的方法和属性来访问和修改一个集合。
要找出一组中的项目数，请检查其只读计数属性：
print("I have \(favoriteGenres.count) favorite music genres.")
// Prints "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.")
}
// 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-以阴影区域表示的各种集合操作的结果。
使用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是set b的超集，因为a包含b中的所有元素。 相反，set b是set a的子集，因为b中的所有元素都包含在a中。 设置b和c彼此不相交，因为它们不共享任何元素。
使用“is equal”运算符（==）来确定两个集合是否包含所有相同的值。
使用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
字典
字典存储集合中相同类型的键和相同类型的值之间的关联，且没有定义的顺序。每个值都与一个唯一键相关联，该键用作字典中该值的标识符。与数组中的项目不同，字典中的项目没有指定的顺序。当需要根据标识符查找值时，您可以使用字典，这与使用真实世界字典查找特定字词的定义的方式大致相同。
注意
Swift的Dictionary类型被桥接到Foundation的NSDictionary类。
有关在Foundation中使用Dictionary和Cocoa的更多信息，请参阅使用Cocoa和Objective-C中的Swift使用Cocoa数据类型（Swift 4.1）。
字典类型速记语法
Swift字典的类型完整地写为Dictionary <Key，Value>，其中Key是可以用作字典键的值的类型，而Value是字典为这些键存储的值的类型。
注意
字典密钥类型必须符合Hashable协议，如集合的值类型。
您也可以用简写形式将字典的类型写为[Key：Value]。尽管这两种形式在功能上是相同的，但是在引用字典类型时，缩写形式是优选的，并且贯穿本指南。
创建一个空字典
与数组一样，您可以使用初始化语法创建一个特定类型的空字典：
var namesOfIntegers = [Int: String]()
// namesOfIntegers is an empty [Int: String] dictionary
本示例创建一个类型为[Int：String]的空字典来存储可读的整数值名称。 它的键是Int类型的，它的值是String类型的。
如果上下文已经提供了类型信息，则可以创建一个空字典，其中包含一个空字典文本，该字典文本写为[：]（冒号位于一对方括号内）：
namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type [Int: String]
使用字典文字创建字典
您还可以使用字典文字来初始化字典，它具有与前面所看到的数组字面相似的语法。 字典文字是将一个或多个键值对作为Dictionary集合书写的简写方式。
键值对是键和值的组合。 在字典文字中，每个键 - 值对中的键和值由冒号分隔。 键值对写成一个列表，用逗号分隔，并用一对方括号包围：
[key 1: value 1, key 2: value 2, key 3: value 3]
下面的示例创建一个字典来存储国际机场的名称。 在这本词典中，关键字是三个字母的国际航空运输协会代码，其值是机场名称：
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin”]
机场字典被声明为具有[String：String]类型，这意味着“字典的键类型为字符串，其值也是字符串类型”。
注意
机场字典被声明为变量（使用var introducer），而不是常数（使用let introducer），因为在下面的示例中将更多的机场添加到字典中。
机场字典用包含两个键值对的字典文字进行初始化。第一双有一个“YYZ”的钥匙和一个“多伦多皮尔逊”的价值。第二对有一个“DUB”键和一个“都柏林”的值。
该字典文字包含两个字符串：字符串对。该键值类型与机场变量声明（仅包含字符串键和仅包含字符串值的字典）的类型相匹配，因此字典文本的分配允许用两种初始项初始化机场字典。
与数组一样，如果使用键和值具有一致类型的字典文字进行初始化，则不必编写字典的类型。机场的初始化可能是用较短的形式写成的：
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin”]
由于文字中的所有键都是相同类型的，并且同样所有的值都是相同类型的，所以Swift可以推断[String：String]是用于机场字典的正确类型。
访问和修改字典
您可以通过其方法和属性或使用下标语法来访问和修改字典。
与数组一样，您可以通过检查其只读计数属性来查找字典中的项目数量：
print("The airports dictionary contains \(airports.count) items.")
// Prints "The airports dictionary contains 2 items."
使用布尔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”。 如果更新前存在该值，则此可选值包含该值的旧值;如果值不存在，则值为零：
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."
您还可以使用下标语法从字典中检索特定键的值。 因为可以请求不存在值的键，所以字典的下标返回字典值类型的可选值。 如果字典包含请求键的值，则下标返回包含该键现有值的可选值。 否则，下标返回零：
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 it
airports["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循环遍历字典中的键值对。 字典中的每一项都作为（键，值）元组返回，并且可以将元组的成员分解为临时常量或变量，作为迭代的一部分：
for (airportCode, airportName) in airports {
print("\(airportCode): \(airportName)")
}
// YYZ: Toronto Pearson
// LHR: London Heathrow
有关for-in循环的更多信息，请参阅For-In循环。
您还可以通过访问其键和值属性来检索字典键或值的可迭代集合：
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 is ["YYZ", "LHR"]
let airportNames = [String](airports.values)
// airportNames is ["Toronto Pearson", "London Heathrow"]
Swift's Dictionary类型没有定义的顺序。 要按特定顺序遍历字典的键或值，请在keys或values属性上使用sorted()方法。