集合类型

Swift语言提供Arrays、Sets和Dictionaries三种基本的集合类型用来存储集合数据。数组（Arrays）是有序数据的集。集合（Sets）是无序无重复数据的集。字典（Dictionaries）是无序的键值对的集。

Swift语言中的Arrays、Sets和Dictionaries中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。

Swift的Arrays、Sets和Dictionaries类型被实现为泛型集合。

集合的可变性

如果创建一个Arrays、Sets或Dictionaries并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项，或者改变集合中的数据项。如果分配成常量，那么它就是不可变的，它的大小和内容都不能被改变。在我们不需要改变集合的时候创建不可变集合是很好的实践。如此Swift编译器可以优化我们创建的集合。

数组

数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。Swift的Array类型被桥接到Foundation中的NSArray类。

数组的简单语法

写Swift数组应该遵循像Array这样的形式，其中Element是这个数组中唯一允许存在的数据类型。我们也可以使用像[Element]这样的简单语法。尽管两种形式在功能上是一样的，但是推荐较短的那种。

创建一个空数组

使用构造语法来创建一个由特定数据类型构成的空数组。如果代码上下文中已经提供了类型信息，例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：[]（一对空方括号）。

var a = [Int]()
print(a)        // []
print(a.count)  // 0
a = []

创建一个带有默认值的数组

Swift中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（count）和适当类型的初始值（repeatedValue）传入数组构造函数。

var a = [Double](count: 3,repeatedValue: 1.25)
print(a)    // [1.25,1.25,1.25]

通过两个数组相加创建一个数组

可以使用加法操作符（+）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来。

var a = [Int](count: 3,repeatedValue: 1)
var b = [Int](count: 4,repeatedValue: 2)
var c = a + b
print(c)    // [1,1,2,2]

用字面量构造数组

使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值。

var a: [Int] = [1,2,3]    // 数组被声明为变量（var关键字创建）而不是常量（let创建）是因为以后可能会有更多的数据项被插入其中

由于Swift的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。

var a = [1,3]

访问和修改数组

• 可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。
• 使用数组的只读属性count来获取数组中的数据项数量。
• 使用布尔值属性isEmpty作为检查count属性的值是否为0的捷径
• 使用append(_:)方法在数组后面添加新的数据项，不可以用下标访问的形式去在数组尾部添加新项。
• 使用加法赋值运算符（+=）也可以直接在数组后面添加一个或多个拥有相同类型的数据项
• 直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中，索引值从零开始
• 使用下标来改变某个已有索引值对应的数据值
• 可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。
• 调用数组的insert(_:atIndex:)方法来在某个具体索引值之前添加数据项
• 使用removeAtIndex(_:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它），数据项被移除后数组中的空出项会被自动填补
• 使用removeLast()把数组中的最后一项移除，并返回被移除的项

如果我们试着对索引越界的数据进行检索或者设置新值的操作，会引发一个运行期错误。

var a = ["abc","def","ghi","jklmn","opqrst","uvwxyz"]
print(a.count)

if a.isEmpty {
    print("a is empty.")
} else {
    print("a isn't empty.")
}

a.append("!@#$%^")
print(a)

a += ["Hello!"]
a += ["你好！","~~~~"]
print(a)

var b = a[2]
a[3] += "==="
print(a)
print(b)

a[1...2] = ["***","^^^","000"]
print(a)

a.insert("new",atIndex: 0)
print(a)

let c = a.removeAtIndex(1)
print(c)
print(a)
 // print(a[11]) // 运行时错误：fatal error: Array index out of range

let d = a.removeLast()
print(d)
print(a)

数组的遍历

• 使用for-in循环来遍历所有数组中的数据项。
• 如果需要每个数据项的值和索引值，可以使用enumerate()方法来进行数组遍历。enumerate()返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历。

let a = ["aaa","bbb","ccc","ddd"]
for i in a {
    print(i)
}

for (i,data) in a.enumerate() {
    print("(i) => (data)") }

集合

集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次时可以使用集合而不是数组。Swift的Set类型被桥接到Foundation中的NSSet类。

集合类型的哈希值

一个类型为了存储在集合中，该类型必须是可哈希化的。也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是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(传递性)

print(0.hashValue)      // 0
print(1.hashValue)      // 1
print(1.2.hashValue)    // 4608083138725491507
print("1".hashValue)    // 4799450059485597623

var a = "123"
var b = "123"
print(a.hashValue)      // 4799450059702945344
print(b.hashValue)      // 4799450059702945344

集合类型语法

Swift中的Set类型被写为Set<Element>，这里的Element表示Set中允许存储的类型，和数组不同的是，集合没有等价的简化形式。

创建和构造一个空的集合

通过构造器语法创建一个特定类型的空集合。此外，如果上下文提供了类型信息，比如作为函数的参数或者已知类型的变量或常量，我们可以通过一个空的数组字面量创建一个空的Set。

var a = Set<Character>()
print(a)    // []

a.insert("a")
print(a)    // ["a"]

a = []
print(a)    // []

用数组字面量创建集合

可以使用数组字面量来构造集合，并且可以使用简化形式写一个或者多个值作为集合元素。一个Set类型不能从数组字面量中被单独推断出来，因此Set类型必须显式声明。然而，由于Swift的类型推断功能，如果你想使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型相同，那么你无须写出Set的具体类型。

var a: Set<String> = ["a","b","ccc"]
print(a)    // ["b","a","ccc"]
var b: Set = [1,3]
print(b)    // [2,3,1]

访问和修改一个集合

• 通过Set的属性和方法来访问和修改一个Set
• 使用其只读属性count获取一个Set的元素数量
• 使用布尔属性isEmpty作为一个缩写形式去检查count属性是否为0
• 调用Set的insert(_:)方法来添加一个新元素
• 调用Set的remove(_:)方法去删除一个元素，如果该值是该Set的一个元素则删除该元素并且返回被删除的元素值，否则如果该Set不包含该值，则返回nil，注意，该函数实际上返回可选类型
• Set中的所有元素可以通过它的removeAll()方法删除
• 使用contains(_:)方法去检查Set中是否包含一个特定的值

var a: Set = [1,5]
print(a)

print(a.count)

if a.isEmpty {
    print("a is empty.")
} else {
    print("a isn't empty.")
}

a.insert(4)
print(a)

print(a.remove(1))      // 返回可选类型：Optional(1)
print(a.remove(100))    // nil
print(a.remove(50) ?? "未找到！")   // 未找到！

if a.contains(2) {
    print("a contains 2.")
} else {
    print("a doesn't contain 2.")
}

a.removeAll()
print(a)    // []

遍历一个集合

使用for-in循环中遍历一个Set中的所有值。由于Swift的Set类型没有确定的顺序，为了按照特定顺序来遍历一个Set中的值可以使用sort()方法，它将根据提供的序列返回一个有序集合。

let a: Set = [4,5,1,3]
for i in a {
    print(i,terminator: "、")   // 5、2、4、1、3、
}
print("")

for i in a.sort() {
    print(i,terminator: "、")   // 1、2、3、4、5、
}

集合操作

你可以高效地完成Set的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。

基本集合操作

• 集合的“交”：intersect(_:)
• exclusiveOr(_:)方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
• 集合的“并”：union(_:)
• 集合的“减法”：subtract(_:)

let a: Set = [1,7,9]
let b: Set = [0,4,6,8]
let c: Set = [2,7]
print(a.union(b).sort())        // [0,3,4,5,6,7,8,9]
print(a.intersect(b).sort())    // []
print(a.subtract(c).sort())     // [1,9]
print(a.exclusiveOr(c).sort())  // [1,9]

集合成员关系和相等

• ==表示两个集合是否相等
• isSubsetOf(_:)判断子集
• isSupersetOf(_:)判断父集
• isStrictSubsetOf(_:)判断子集但是不相等
• isStrictSupersetOf(_:)判断父集但是不相等
• isDisjointWith(_:)判断两个集合没有交集

let a: Set = [1,3]
let b: Set = [1,3]

print(a == b)   // true

let c: Set = [1]
print(a.isSupersetOf(c))    // true
print(c.isSubsetOf(a))      // true
print(a.isStrictSupersetOf(c))  // true
print(c.isStrictSubsetOf(a))    // true

let d: Set = [4,6]
print(a.isDisjointWith(d))      // true

字典

字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

Swift的Dictionary类型被桥接到Foundation的NSDictionary类。

字典类型快捷语法

Swift的字典使用Dictionary<Key,Value>定义，其中Key是字典中键的数据类型，Value是字典中对应于这些键所存储值的数据类型。一个字典的Key类型必须遵循Hashable协议，就像Set的值类型。也可以用[Key: Value]这样快捷的形式去创建一个字典类型。虽然这两种形式功能上相同，但是后者是首选。

创建一个空字典

使用构造语法创建一个拥有确定类型的空字典。如果上下文已经提供了类型信息，我们可以使用空字典字面量来创建一个空字典，记作[:]。

var a = [Int: String]()
print(a)    // [:]
a = [:]

用字典字面值创建字典

可以使用字典字面量来构造字典，字典字面量是一种将一个或多个键值对写作Dictionary集合的快捷途径。一个键值对是一个key和一个value的结合体。在字典字面量中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含、由逗号分割。和数组一样，我们在用字典字面量构造字典时，如果它的键和值都有各自一致的类型，那么就不必写出字典的类型。

var a: [Int: String] = [1: "Hello",2: "World",3: "!"]
print(a)    // [2: "World",3: "!",1: "Hello"]
a = [4: "???",5: "@@@"]
print(a)    // [5: "@@@",4: "???"]

访问和修改字典

• 通过字典的方法和属性来访问和修改字典，或者通过使用下标语法
• 通过字典的只读属性count来获取某个字典的数据项数量
• 使用布尔属性isEmpty来快捷地检查字典的count属性是否等于0
• 可以在字典中使用下标语法来添加新的数据项。可以使用一个恰当类型的键作为下标索引，并且分配恰当类型的新值
• 使用下标语法来改变特定键对应的值
• 作为另一种下标方法，字典的updateValue(_:forKey:)方法可以设置或者更新特定键对应的值。该方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和下标方法不同，这个方法返回更新值之前的原值，实际上返回会返回对应值的类型的可选值。这样使得我们可以检查更新是否成功。
• 使用下标语法来在字典中检索特定键对应的值。因为有可能请求的键没有对应的值存在，字典的下标访问会返回对应值的类型的可选值
• 使用下标语法来通过给某个键的对应值赋值为nil来从字典里移除一个键值对
• removeValueForKey(_:)方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的值或者在没有值的情况下返回nil，也就是说，返回可选类型

var a = [1: "Hello",2: "world",3: "!!!"]

print(a.count)  // 3

if a.isEmpty {
    print("a is empty.")
} else {
    print("a isn't empty.")
}

a[4] = "???"
print(a)

a[1] = "Hello-new"
print(a)

print(a.updateValue("WWWWWWW",forKey: 2))  // 返回可选类型：Optional("world")
print(a.updateValue("Dog",forKey: 8))      // 返回nil

print(a[1])     // 返回可选类型：Optional("Hello-new")
print(a[100] ?? "未找到！")     // 未找到！

a[1] = nil
print(a)

print(a.removeValueForKey(2))   // 返回可选类型：Optional("WWWWWWW")
print(a.removeValueForKey(1000))    // nil
print(a)

字典遍历

• 使用for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都以(key,value)元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组
• 通过访问keys或者values属性，我们也可以遍历字典的键或者值
• 如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受Array实例的API的参数，可以直接使用keys或者values属性构造一个新数组
• Swift的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的keys或values属性使用sort()方法

var a = [1: "Hello",3: "!!!"]

for (key,value) in a {
    print("(key) => (value)") } for i in a.keys.sort(){ print(i) } for i in a.values.sort() { print(i) } let b = [Int](a.keys) print(b) let c = [String](a.values) print(c)