数组(Arrays)
数组的简化语法（Array Type Shorthand Syntax）
- Array<Element>
- [Element] // 推荐用这种
创建一个空数组（Creating an Array with a Default Value）
- 可以使用构造语法来创建一个由特定数据类型构成的空数组：
- 在元素类型已知的情况下，我们可以使用空数组语句创建一个空数组，[]
（一对空方括号）
var 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] 类型的。
创建一个带有默认值的数组(Creating an Array with a Default Value)
Swift 中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法
通过两个数组相加创建一个数组(Creating an Array by Adding Two Arrays Together)
我们可以使用加法操作符（+）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：
let threeDoubles = [Double](count: 3, repeatedValue: 0.0)
// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]
let anotherThreeDoubles = [Double](count: 3, repeatedValue: 2.5)
// anotherThreeDoubles 被推断为 [Double]，等价于 [2.5, 2.5, 2.5]
let sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推断为 [Double]，等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
用字面量构造数组(Creating an Array with an Array Literal)
我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值：
访问和修改数组(Accessing and Modifying an Array)
- 可以使用数组的只读属性count来获取数组中的数据项数量：
- 使用布尔值属性isEmpty作为检查count属性的值是否为 0 的捷径
- 也可以使用append(_:)方法在数组后面添加新的数据项
- 使用加法赋值运算符（+=）也可以直接在数组后面添加一个或多个拥有相同类型的数据项
- 可以直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中
- 可以用下标来改变某个已有索引值对应的数据值
- 可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的
- 调用数组的insert(_:atIndex:)方法来在某个具体索引值之前添加数据项
- 可以使用removeAtIndex(_:)方法来移除数组中的某一项
- 如果我们只想把数组中的最后一项移除，可以使用removeLast()
方法
数组的遍历(Iterating Over an Array)
- 可以使用for-in循环来遍历所有数组中的数据项
- 如果我们同时需要每个数据项的值和索引值，可以使用enumerate()方法来进行数组遍历。enumerate()返回一个由每一个数据项索引值和数据值组成的元组。
var shoppingList = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。
print("The shopping list contains \(shoppingList.count) items.")
// 输出 "The shopping list contains 2 items."（这个数组有2个项）
if shoppingList.isEmpty {
print("The shopping list is empty.")
} else {
print("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."（shoppinglist 不是空的）
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项
shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 现在有7项
// "Maple Syrup" 现在是这个列表中的第一项
let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"
firstItem = shoppingList[0]
// firstItem 现在等于 "Six eggs"
let apples = shoppingList.removeLast()
// 数组的最后一项被移除了
// shoppingList 现在只有5项，不包括 Apples
// apples 常量的值现在等于 "Apples" 字符串
for item in shoppingList {
print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas
for (index, value) in shoppingList.enumerate() {
print("Item \(String(index + 1)): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas
数组的下标是整数，比String的要好用
集合（Sets）
集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。
集合类型语法(Set Type Syntax)
Swift 中的Set类型被写为Set<Element>，这里的Element表示Set中允许存储的类型，和数组不同的是，集合没有等价的简化形式。
创建和构造一个空的集合(Creating and Initializing an Empty Set)
- 可以通过构造器语法创建一个特定类型的空集合：
- 如果上下文提供了类型信息，可以通过一个空的数组字面量创建一个空的Set
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 现在含有1个 Character 类型的值
letters = []
// letters 现在是一个空的 Set, 但是它依然是 Set<Character> 类型
用数组字面量创建集合（Creating a Set with an Array Literal）
- 可以使用数组字面量来构造集合，并且可以使用简化形式写一个或者多个值作为集合元素。
- 一个Set类型不能从数组字面量中被单独推断出来，因此Set类型必须显式声明。
访问和修改一个集合（Accessing and Modifying a Set）
- 为了找出一个Set中元素的数量，可以使用其只读属性count
- 使用布尔属性isEmpty作为一个缩写形式去检查count属性是否为0
- 你可以通过调用Set的insert(_:)方法来添加一个新元素
- 可以通过调用Set的remove(_:)方法去删除一个元素，如果该值是该Set的一个元素则删除该元素并且返回被删除的元素值，否则如果该Set不包含该值，则返回nil
- Set中的所有元素可以通过它的removeAll()方法删除
- 使用contains(_:)方法去检查Set中是否包含一个特定的值
遍历一个集合（Iterating Over a Set）
- 可以在一个for-in循环中遍历一个Set中的所有值
- Swift 的Set类型没有确定的顺序，为了按照特定顺序来遍历一个Set中的值可以使用sort()方法，它将根据提供的序列返回一个有序集合
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres 被构造成含有三个初始值的集合
// Set不能省<String>可以省略
// 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 现在包含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.sort() {
print("\(genre)")
}
// prints "Classical"
// prints "Hip hop"
// prints "Jazz
集合操作（Performing Set Operations）
基本集合操作（Fundamental Set Operations）
- 使用intersect(_:)方法根据两个集合中都包含的值创建的一个新的集合。
- 使用exclusiveOr(_:)方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
- 使用union(_:)方法根据两个集合的值创建一个新的集合。
- 使用subtract(_:)方法根据不在该集合中的值创建一个新的集合。
集合基本操作.png
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).sort()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersect(evenDigits).sort()
// []
oddDigits.subtract(singleDigitPrimeNumbers).sort()
// [1, 9]
oddDigits.exclusiveOr(singleDigitPrimeNumbers).sort()
// [1, 2, 9]
集合成员关系和相等（Set Membership and Equality）
- 使用“是否相等”运算符(==)来判断两个集合是否包含全部相同的值。
- 使用isSubsetOf(_:)方法来判断一个集合中的值是否也被包含在另外一个集合中。
- 使用isSupersetOf(_:)方法来判断一个集合中包含另一个集合中所有的值。
- 使用isStrictSubsetOf(:)或者isStrictSupersetOf(:)方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。
- 使用isDisjointWith(_:)方法来判断两个集合是否不含有相同的值(是否没有交集)。
集合的关系.png
- b是a的子集
- b是a的严格子集
- a != c
- b和c不相关
let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]
houseAnimals.isSubsetOf(farmAnimals)
// true
farmAnimals.isSupersetOf(houseAnimals)
// true
farmAnimals.isDisjointWith(cityAnimals)
// true
字典（Dictionaries）
字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典。
字典类型快捷语法（Dictionary Type Shorthand Syntax）
- 字典使用Dictionary<Key, Value>定义，其中Key是字典中键的数据类型，Value是字典中对应于这些键所存储值的数据类型。
- 可以用[Key: Value]这样快捷的形式去创建一个字典类型。推荐用这种
Creating an Empty Dictionary
- 可以像数组一样使用构造语法创建一个拥有确定类型的空字典
- 如果上下文已经提供了类型信息，我们可以使用空字典字面量来创建一个空字典，记作[:]（中括号中放一个冒号）：
var namesOfIntegers = [Int: String]()
// namesOfIntegers 是一个空的 [Int: String] 字典
namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对
namesOfIntegers = [:]
// namesOfIntegers 又成为了一个 [Int: String] 类型的空字典
用字典字面量创建字典（Creating a Dictionary with a Dictionary Literal）
- 可以使用字典字面量来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将一个或多个键值对写作Dictionary
集合的快捷途径。 - 在用字典字面量构造字典时，如果它的键和值都有各自一致的类型，那么就不必写出字典的类型。
访问和修改字典（Accessing and Modifying a Dictionary）
- 可以通过字典的只读属性count来获取某个字典的数据项数量
- 使用布尔属性isEmpty来快捷地检查字典的count属性是否等于0
- 可以在字典中使用下标语法来添加新的数据项，如果key已经存在，则会改变对应key的值
- updateValue(_:forKey:)方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。返回更新值之前的原值，是一个可选值（新建的情况返回nil）。
- 可以使用下标语法来通过给某个键的对应值赋值为nil来从字典里移除一个键值对
- removeValueForKey(_:)方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回nil
字典遍历（Iterating Over a Dictionary）
- 可以使用for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都以(key, value)元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组
- 通过访问keys或者values属性，我们也可以遍历字典的键或者值：
- 如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受Array实例的 API 的参数，可以直接使用keys或者values属性构造一个新数组
- 为了以特定的顺序遍历字典的键或值，可以对字典的keys或values属性使用sort()方法。
var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
// var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
print("The dictionary of airports contains \(airports.count) items.")
// 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项）
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
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."
// 网络来的数据，最好都采用这种结构，不要怕麻烦，安全是第一位的
airports["APL"] = "Apple Internation"
// "Apple Internation" 不是真的 APL 机场, 删除它
airports["APL"] = nil
// APL 现在被移除了
if let removedValue = airports.removeValueForKey("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 (airportCode, airportName) in airports {
print("\(airportCode): \(airportName)")
}
// YYZ: Toronto Pearson
// LHR: London Heathrow
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
let airportCodes = [String](airports.keys)
// airportCodes 是 ["YYZ", "LHR"]
let airportNames = [String](airports.values)
// airportNames 是 ["Toronto Pearson", "London Heathrow"]
