集合类型
Swift 语言提供数组（Array）、集合（Set）和字典（Dictionary）三种基本的集合类型用来存储集合数据。
- 数组是有序数据的集
- 集合是无序无重复数据的集
- 字典是无序的键值对的集
1. 数组（Arrays）
1.1 定义
- 数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。
- 创建一个空数组
var someInts = [Int]() // someInts 的值类型被推断为 [Int]
print("someInts is of type [Int] with \(someInts.count) items.") // 打印“someInts is of type [Int] with 0 items.”
someInts.append(3) // someInts 现在包含一个 Int 值
someInts = [] // someInts 现在是空数组，但是仍然是 [Int] 类型的。
- 创建一个带有默认值的数组
// Swift 中的 Array 类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。可以把准备加入新数组的数据项数量（count）和适当类型的初始值（repeating）传入数组构造函数
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 被推断为 [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]
var shoppingList1: [String] = ["Eggs", "Milk"] // shoppingList 已经被构造并且拥有两个初始项。
var shoppingList2 : ["Eggs", "Milk"] // 由于 Swift 的类型推断机制，当你用字面量构造拥有相同类型值数组的时候，不必把数组的类型定义清楚
1.2 访问和修改数组
- 你可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。
// 使用数组的只读属性 count 来获取数组中的数据项数量：
var shoppingList = ["Eggs", "Milk"]
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”
// 使用下标来改变某个有效索引值对应的数据值：
shoppingList[0] = "Six eggs" // 其中的第一项现在是“Six eggs”而不是“Eggs”
// 使用下标来一次改变一系列数据值
shoppingList[4...6] = ["Bananas", "Apples"] // shoppingList 现在有6项
// 调用数组的 insert(_:at:) 方法在某个指定索引值之前添加数据项：
shoppingList.insert("Maple Syrup", at: 0) // shoppingList 现在有7项，第一项是“Maple Syrup”
// 使用 remove(at:) 方法来移除数组中的某一项，这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（不需要的时候就可以无视它）：
let mapleSyrup = shoppingList.remove(at: 0) // 索引值为0的数据项被移除，shoppingList 现在只有6项，而且不包括 Maple Syrup，mapleSyrup 常量的值等于被移除数据项“Maple Syrup”
// 使用 removeLast() 把数组中的最后一项移除
let apples = shoppingList.removeLast() // 数组的最后一项被移除了, shoppingList 现在只有5项，不包括 Apples, apples 常量的值现在等于字符串“Apples”
1.3数组的遍历
- 使用 for-in 循环来遍历数组中所有的数据项：
var shoppingList = ["Six eggs", "Milk", "Flour", "Baking Powder", "Bananas"]
for item in shoppingList {
print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas
- 使用 enumerated() 方法来进行数组遍历，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
2. 集合（Sets）
2.1 定义
- 集合用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。
2.2 集合类型的哈希值
-
一个类型为了存储在集合中，该类型必须是可哈希化的，也就是说，该类型必须提供一个方法来计算它的哈希值。
-
一个哈希值是 Int 类型的，相等的对象哈希值必须相同。
-
比如 a == b，因此必须： a.hashValue == b.hashValue。
-
Swift 的所有基本类型（比如 String、Int、Double 和 Bool）默认都是可哈希化的，可以作为集合值的类型或者字典键的类型。
-
没有关联值的枚举成员值（在 枚举 有讲述）默认也是可哈希化的。
注意 1. 你可以使用自定义的类型作为集合值的类型或者是字典键的类型，但需要使自定义类型遵循 Swift 标准库中的 Hashable 协议。遵循 Hashable 协议的类型需要提供一个类型为 Int 的可读属性 hashValue。由类型的 hashValue 属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。 2. 因为 Hashable 协议遵循 Equatable 协议，所以遵循该协议的类型也必须提供一个“是否相等”运算符（==）的实现。这个 Equatable 协议要求任何遵循 == 实现的实例间都是一种相等的关系。 3. 也就是说，对于 a,b,c 三个值来说，== 的实现必须满足下面三种情况： a == a(自反性) a == b 意味着 b == a(对称性) a == b && b == c 意味着 a == c(传递性)
2.3 集合类型语法
- 创建和构造一个空的集合
var letters = Set<Character>() // 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 现在含有1个 Character 类型的值
letters = [] // letters 现在是一个空的 Set，但是它依然是 Set<Character> 类型
var favoriteGenres1: Set<String> = ["Rock", "Classical", "Hip hop"]
var favoriteGenres2: Set = ["Rock", "Classical", "Hip hop"]
2.4 访问和修改
- 可以通过集合的属性和方法来对其进行访问和修改。
var favoriteGenres2: Set = ["Rock", "Classical", "Hip hop"]
// 获取一个集合中元素的数量，可以使用其只读属性 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.”
// 通过调用集合的 insert(_:) 方法来添加一个新元素：
favoriteGenres.insert("Jazz") // favoriteGenres 现在包含4个元素
// 通过调用集合的 remove(_:) 方法去删除一个元素，如果它是该集合的一个元素则删除它并且返回它的值，若该集合不包含它，则返回 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.”
2.5 遍历一个集合
- 你可以在一个 for-in 循环中遍历一个集合中的所有值。
for genre in favoriteGenres {
print("\(genre)")
}
// Classical
// Jazz
// Hip hop
- Swift 的 Set 类型没有确定的顺序，为了按照特定顺序来遍历一个集合中的值可以使用 sorted() 方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符 < 对元素进行比较的结果来确定。
for genre in favoriteGenres.sorted() {
print("\(genre)")
}
// Classical
// Hip hop
// Jazz
2.6 集合操作
可以高效地完成集合的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。
- 使用 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]
- 使用“是否相等”运算符（==）来判断两个集合包含的值是否全部相同。
- 使用 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
3. 字典
3.1 定义
- 字典是一种无序的集合，它存储的是键值对之间的关系，其所有键的值需要是相同的类型，所有值的类型也需要相同。每个值（value）都关联唯一的键（key），键作为字典中这个值数据的标识符。
- 创建一个空字典
// 使用构造语法创建一个拥有确定类型的空字典：
var namesOfIntegers = [Int: String]() // namesOfIntegers 是一个空的 [Int: String] 字典
namesOfIntegers[16] = "sixteen" // namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:] // namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
- 用字典字面量创建字典
var airports1: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] // airports 字典被声明为一种 [String: String] 类型
var airports2 = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] // 因为这个语句中所有的键和值都各自拥有相同的数据类型，Swift 可以推断出 [String: String] 是 airports 字典的正确类型。
3.2 访问和修改字典
// 通过 Dictionary 的只读属性 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:) 这个方法返回更新值之前的原值。这样使得你可以检查更新是否成功。
// 举例来说：对于存储 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 来从字典里移除一个键值对：
airports["APL"] = "Apple Internation" // “Apple Internation”不是真的 APL 机场，删除它
airports["APL"] = nil // APL 现在被移除了
// 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.")
} // 打印“The removed airport's name is Dublin Airport.”
updateValue(_:forKey:) 方法会返回对应值类型的可选类型。举例来说：对于存储 String 值的字典，这个函数会返回一个 String? 或者“可选 String”类型的值。如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是 nil 。
3.3 字典遍历
- 使用 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
- 如果需要使用某个字典的键集合或者值集合来作为某个接受 Array 实例的 API 的参数，可以直接使用 keys 或者 values 属性构造一个新数组：
let airportCodes = [String](airports.keys) // airportCodes 是 ["YYZ", "LHR"]
let airportNames = [String](airports.values) // airportNames 是 ["Toronto Pearson", "London Heathrow"]
Swift 的 Dictionary 是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的 keys 或 values 属性使用 sorted() 方法。
320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
