Swift 3.0 学习笔记-3-集合类型

iOS Swift

前言：
swift3.0 学习笔记主要参考苹果开发者官网The Swift Programming Language (Swift 3.1)教程 以及 Swift 中文网。
更纯粹的阅读的体验请移步至：
https://www.zybuluo.com/kakadee/note/721367

Swift 3.0 提供了三种集合类型来存放多个值——数组(Array)、字典(Dictionary)和集合（Set）。数组把相同类型的值存放在一个有序链表里。字典把相同类型的值存放在一个无序集合里，集合与数组的不同点在于它是无序的。这些值可以通过唯一标识符（也就是键）来引用和查找。

1. 数组 （Array）

数组在一个有序链表里存储了多个类型相同的值。同一个值可以在数组的不同位置出现多次。

1.1 数组字面量

可以用一个数组字面量来初始化一个数组，简单地把一个或多个值放在一起就可以了。数组字面量的写法是一行用逗号隔开的值，并在行的两端用一对方括号包起来：[value 1, value 2, value 3]

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

1.2 数组的存取与修改

• count 读取数组中元素的数量

var shoppingList = ["Eggs", "Milk"] 
var num = shoppingList.count //num 值为 2

• isEmpty 判断数组是否为空

if shoppingList.isEmpty {
    print("The shopping list is empty.")
}

• append 或者 += 数组末尾添加元素

shoppingList.append("Flour")
shoppingList += "Baking Powder"
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]

• 替换元素

shoppingList[0] = "Six eggs"
// 这个清单的第一项现在是“Six eggs”了，而不是"Eggs" 
shoppingList[4...6] = ["Bananas", "Apples"] 
// 将shoppingList的第4到6项替换成"Bananas", "Apples"

注意： 不能使用下标语法添加新元素到数组末尾。如果试图使用超出数组范围的下标来取用或存放一个元素，会产生运行时错误。在使用一个索引值之前，应该把它跟数组的count属性进行比较，以检测它是否有效。除非count是0（意味着这是个空数组），数组的最大有效索引总是count - 1，因为数组的索引是从0开始的。

• insert 插入元素

shoppingList.insert("Maple Syrup", atIndex: 0)

• removeAtIndex 删除元素

let mapleSyrup = shoppingList.removeAtIndex(0)
let apples = shoppingList.removeLast() 
// 数组的最后一个元素被删除了

• 初始化
  Swift的数组还提供了一个生成若干个重复元素组成的数组的初始化函数。把要添加到新数组里的元素数量（count）和一个合适的默认值(repeatedValue)传参给该初始化函数即可：

var threeDoubles = Double[](count: 3, repeatedValue: 0.0)

2 字典（Dictionary）

字典是一种存储多个类型相同的值的容器。每个值都和一个唯一的键相对应，这个键在字典里就是其对应值的唯一标识。跟数组不同，字典里的元素并没有特定的顺序。在“字典”中使用键来查询其对应值的方式，跟在“现实世界的字典”中使用单词查询单词定义差不多。

Swift的字典对它们能存放的键和值的类型是明确的。这不同于Objective-C的NSDictionary类和NSMutableDictionary类，Objective-C的字典能存储任何类型的对象作为键或值，并且不提供关于这些对象自身的任何信息。在Swift里，任何一个特定的字典键和值，其类型总会被确定下来，或者通过显式的类型说明，或者通过类型推断。

Swift的字典类型是Dictionary，其中KeyType是字典中键的类型，ValueType是字典中值的类型。

2.1 字典字面量

可以用一个字典字面量来初始化一个数组，其语法格式类似于之前看到的数组字面量。字典字面量是写一个具有单个或多个键值对字典的简便方法。

键值对是一个键和一个值的组合。在字典字面量中，每对键值对中的键和值使用冒号分开，键值对之间用逗号分开，用一对方括号将这些键值对包起来：
[key 1: value 1, key 2: value 2, key 3: value 3]

下面的例子创建了一个存储国际机场名字的字典，在这个字典中，键是三字母的国际航空运输协会码，值是机场的名字：

var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"] 

2.2 字典的存取与修改

• count 读取字典元素个数

print("The dictionary of airports contains \(airports.count) items.")
// 输出"The dictionary of airports contains 2 items." 

• 添加、更改元素

可以使用下标语法向字典中添加新的元素。以一个合适类型的新键作为下标索引，并且赋给它一个合适类型的值：

airports["LHR"] = "London"
// 字典airports现在包含3个元素 

也可以使用下标语法来改动某个键对应的值：

airports["LHR"] = "London Heathrow"
// "LHR"的值被改为"London Heathrow 

在对特定键设置或更新值时，也可以使用updateValue(forKey:)函数来替代下标。就像上面例子中的下标语法，updateValue(forKey:)函数在键不存在的时候就设置一个新值，在键存在的时候就更新该值。和下标语法不一样的是，updateValue(forKey:)函数在更新一个值之后，会返回原来的老值。这让你能够检测是否发生了值的更新。

updateValue(forKey:)函数返回一个值的类型的可选值。例如一个值类型为String的字典，该函数返回值的类型为String?。如果更新前该键的值存在，函数返回值就是该键更新前的值，如果不存在，函数返回值就是nil：

if let oldValue = airports.updateValue("Dublin International", forKey: "DUB") {
    print("The old value for DUB was \(oldValue).")
}
// 输出 "The old value for DUB was Dublin. 

• 删除键值对

可以使用下标语法把一个键对应的值赋为nil来删除该键值对：

airports["APL"] = "Apple International"
// "Apple International" 不是APL的机场，所以要删除它
airports["APL"] = nil
// APL键值对已经从字典中删除了 

从字典中删除键值对也可以使用removeValueForKey函数。如果该键值对存在，该函数就返回本删掉的值，如果不存在，就返回nil：

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.")
}
// 输出 "The removed airport's name is Dublin International." 

• 生成一个空字典

var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers是一个Dictionary<Int, String>类型的空字典

如果上下文中已经提供了类型信息，可以使用空字典字面量[:]来创建一个空字典：

namesOfIntegers[16] = "sixteen"
// namesOfIntegers现在含有1个键值对
namesOfIntegers = [:]
// namesOfIntegers又成为一个类型为Int，String的空字典 

3 集合（Set）

集合存放相同类型的不同值，它与数组的区别在于它是无序的。集合的声明方式和常用方法与数组类似，在此不多做介绍。下面主要介绍集合间的一些方法。

• 交 a.intersection(b)
• 并 a.union(b)
• 对等分差 a.symmetricDifference(b)
• 去除 a.subtracting(b)

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 a: Set = [1, 3, 5, 7]
let b: Set = [1, 3, 5]
let c: Set = [2, 4, 6]
b.isDisjoint(with:a) //true
a.isSuperset(of:b) //true
b.isStrictSubset(of:a) //true
a.isStrictSuperset(of:b) //true
a.isDisjoint(with:c) //true