Swift 三种基本的集合类型用来存储集合数据,存储的数据值类型必须明确。。
Arrays 数组是有序数据的集。
Sets 集合是无序无重复数据的集。
Dictionaries字典是无序的键值对的集。
注意：
Swift 的Arrays、Sets和Dictionaries类型被实现为泛型集合。
集合的可变性
他们的可变性取决于创建时使用的是 变量还是常量(大小和内容都不可变)
数组(Arrays)
数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
注意:
Swift 的Array类型被桥接到Foundation中的NSArray类。
更多关于在Foundation和Cocoa中使用Array的信息，参见 *Using Swift with Cocoa and Objective-C (Swift 4.1)
* 中使用 Cocoa 数据类型部分。
数组的简单语法
Array<Element> 其中Element是这个数组中唯一允许存在的数据类型。也可以使用像[Element]这样的简单语法。推荐较短的那种
创建数组的方式
- 空数组
var someInts = [Int]()
- 构造函数
Array(repeating: count)
var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]
- 组合数组
+
var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles : [2.5, 2.5, 2.5] 被推断为 [Double]
var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles : [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
- 用数组字面量构造数组
var shoppingList: [String] = ["Eggs", "Milk"]
// [String] 可省略，编译器会自动推断类型
访问和修改数组
print("The shopping list contains \(shoppingList.count) items.")
// 输出 "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.")
}
// "The shopping list is not empty."
append(_:) 在数组后面添加新的数据项：
shoppingList.append("Flour")
+= 可以直接在数组后面添加一个或多个拥有相同类型的数据项：
shoppingList += ["Baking Powder"]
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
下标语法
var firstItem = shoppingList[0]
// 第一项是 "Eggs"
shoppingList[0] = "Six eggs"
// 其中的第一项现在是 "Six eggs" 而不是 "Eggs"
利用下标来一次改变一系列数据值
shoppingList[4...6] = ["Bananas", "Apples"]
// 将 4、5、6 三个数据替换成 2 个
注意：
不可以用下标访问的形式去在数组尾部添加新项。
insert(_:at:) 在某个具体索引值之前添加数据项：
shoppingList.insert("Maple Syrup", at: 0)
// "Maple Syrup" 现在是这个列表中的第一项
remove(at:) 移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）：
let mapleSyrup = shoppingList.remove(at: 0)
// mapleSyrup : "Maple Syrup"
removeLast()把数组中的最后一项移除,返回被移除的数据项：
let apples = shoppingList.removeLast()
// apples : "Apples"
数组的遍历
for-in遍历所有数组中的数据项：
for item in shoppingList {
print(item)
}
enumerated()返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：
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
集合（Sets）
集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。
注意：
Swift的Set类型被桥接到Foundation中的NSSet类。
关于使用Foundation和Cocoa中Set的知识，参见 *Using Swift with Cocoa and Objective-C (Swift 4.1)
* 中使用 Cocoa 数据类型部分。
集合类型的哈希值
一个类型为了存储在集合中，该类型必须是可哈希化的--也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是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(传递性)
集合类型语法
Set<Element>，Element表示Set中允许存储的类型，集合没有等价的简化形式。
创建和构造集合
- 通过构造器语法创建一个特定类型的空集合：
var letters = Set<Character>()
- 用数组字面量创建集合
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
这个favoriteGenres变量被声明为“一个String值的集合”，写为Set<String>
Set类型不能从数组字面量中被单独推断出来，因此Set类型必须显式声明。但类型可以推断。
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
访问和修改一个集合
count 找出一个Set中元素的数量
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."
insert(_:) 添加一个新元素：
favoriteGenres.insert("Jazz")
remove(_:) 删除一个元素，如果该值是该Set的一个元素则删除该元素并且返回被删除的元素值，否则如果该Set不包含该值，则返回nil。
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(_:)检查是否包含一个特定的值：
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
sorted()， Set类型没有确定的顺序，为了按照特定顺序来遍历一个Set中的值可以使用sorted()方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符'<'对元素进行比较的结果来确定。
for genre in favoriteGenres.sorted() {
print("\(genre)")
}
// prints "Classical"
// prints "Hip hop"
// prints "Jazz
集合操作
基本集合操作
下面的插图描述了两个集合-a和b-以及通过阴影部分的区域显示集合各种操作的结果。
[图片上传失败...(image-be26af-1522652891729)]
-
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,以及通过重叠区域表述集合间共享的元素。集合a是集合b的父集合，因为a包含了b中所有的元素，相反的，集合b是集合a的子集合，因为属于b的元素也被a包含。集合b和集合c彼此不关联，因为它们之间没有共同的元素。
[图片上传失败...(image-a882cb-1522652891729)]
-
==判断两个集合是否包含全部相同的值。 - 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
字典
字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典。
字典类型简化语法
Dictionary<Key, Value>，其中Key是字典中键的数据类型，Value是字典中对应于这些键所存储值的数据类型。
[Key: Value]可以用这样简化的形式去创建一个字典类型。
注意：
一个字典的Key类型必须遵循Hashable协议，就像Set的值类型。
创建字典
- 使用构造语法创建一个拥有确定类型的空字典：
var namesOfIntegers = [Int: String]()
// namesOfIntegers 是一个空的 [Int: String] 字典
namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:]
// namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
- 用字典字面量创建字典
[key 1: value 1, key 2: value 2, key 3: value 3]
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
//自动推断类型
访问和修改字典
通过字典的方法和属性来访问和修改字典，或者通过使用下标语法。
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.")
}
下标形式
airports["LHR"] = "London"
// airports 字典现在有三个数据项
airports["LHR"] = "London Heathrow"
// "LHR"对应的值 被改为 "London Heathrow
updateValue(_:forKey:) 设置(不存在时)或者更新特定键对应的值。并返回更新值之前的原值。这样使得我们可以检查更新是否成功。
该方法会返回对应值的类型的可选值。如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是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."
使用下标语法来在字典中检索特定键对应的值。因为有可能请求的键没有对应的值存在，字典的下标访问会返回对应值的类型的可选值。
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"
airports["APL"] = nil
// APL 现在被移除了
removeValue(forKey:)可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回nil：
if let removedValue = airports.removeValue(forKey: "DUB") {
print("The removed airport's name is \(removedValue).")
}
字典遍历
for-in遍历某个字典中的键值对。每一个字典中的数据项都以(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
使用keys或者values属性构造一个新数组：
let airportCodes = [String](airports.keys)
// airportCodes 是 ["YYZ", "LHR"]
let airportNames = [String](airports.values)
// airportNames 是 ["Toronto Pearson", "London Heathrow"]
Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的keys或values属性使用sorted()方法。
