Swift 入门学习：集合（Collection）类型趣谈-上

概览

集合的概念在任何编程语言中都占有重要的位置，正所谓："古来聚散地，宿昔长荆棘；游人聚散中，一片湖光里"。把那一片片、一瓣瓣、一粒粒"可耐"的小精灵全部收拢、吸纳的井然有序、条条有理，怎能不让我们满心欢喜呢？

在这里，我们就和 Swift 语言刚入门的小伙伴们一起来闲聊一番关于集合有趣的内容吧。

在本篇博文中，您将学到如下内容：

概览
[1. 数据总动员：集合！](#1. 数据总动员：集合！)
[2. 数组](#2. 数组)
[3. 字典](#3. 字典)
总结

在下篇中，我们将继续介绍更多的集合类型，以及其它集合类型有趣的扩展知识。

Swift 中集合的概念简约却不简单，那还等什么呢？

Let's collect it now！！!😉

1. 数据总动员：集合！

Swift 语言以其独有的简洁、安全、现代化等特性迅速吸引着众多已秃和还未秃的小码农们！在 Swift 语言标准库中包含了 3 种"著名"的集合类型（Collection Types），它们分别是：Array、Dictionary 和 Set。

在 Swift 中之所以认为它们是集合类型，是因为它们都遵守了 Collection 协议：

而 Collection 又遵守着 Sequence 协议，环环相套、生生不息。

在 Swift 语言中，集合的本质是容器，里面存放着有序或无序的元素。而遵守 Collection 协议的一大好处是只需实现简单几个属性和方法，我们即可免费获得全套海量通用的集合操作，比如：map()、randomElement()、prefix() 方法等等。

其中，一些方法实际是否适用还要看集合元素的"脸色"，比如下面这些方法就要求方法元素类型遵守 Equatable 协议：

swift 复制代码

func contains<C>(C) -> Bool
func firstIndex(of: Self.Element) -> Self.Index?
func split(separator: Self.Element, maxSplits: Int, omittingEmptySubsequences: Bool) -> [Self.SubSequence]

其实，小伙伴们可能不知道的是：如果遵守 Collection 协议的类型都算集合，恐怕在 Swift 中符合条件的类型得有一个"加强连"：

swift 复制代码

遵守 Collection 的类型：

AnyBidirectionalCollection
AnyCollection
AnyRandomAccessCollection
AnyRegexOutput
Array
ArraySlice
ClosedRange
Conforms when Bound conforms to Strideable and Bound.Stride conforms to SignedInteger.
CollectionDifference
CollectionOfOne
ContiguousArray
DefaultIndices
Conforms when Elements conforms to BidirectionalCollection.
Dictionary
Conforms when Key conforms to Hashable.
Dictionary.Keys
Conforms when Key conforms to Hashable.
Dictionary.Values
Conforms when Key conforms to Hashable.
EmptyCollection
FlattenSequence
Conforms when Base conforms to BidirectionalCollection and Base.Element conforms to BidirectionalCollection.
Int.Words
Int16.Words
Int32.Words
Int64.Words
Int8.Words
KeyValuePairs
LazyDropWhileSequence
Conforms when Base conforms to Collection.
LazyFilterSequence
Conforms when Base conforms to BidirectionalCollection.
LazyMapSequence
Conforms when Base conforms to RandomAccessCollection.
LazyPrefixWhileSequence
Conforms when Base conforms to BidirectionalCollection.
LazySequence
Conforms when Base conforms to RandomAccessCollection.
Range
Conforms when Bound conforms to Strideable and Bound.Stride conforms to SignedInteger.
Repeated
ReversedCollection
Conforms when Base conforms to RandomAccessCollection.
Set
Conforms when Element conforms to Hashable.
Slice
Conforms when Base conforms to RandomAccessCollection.
String
String.UTF16View
String.UTF8View
String.UnicodeScalarView
Substring
Substring.UTF16View
Substring.UTF8View
Substring.UnicodeScalarView
UInt.Words
UInt16.Words
UInt32.Words
UInt64.Words
UInt8.Words
Unicode.Scalar.UTF16View
Unicode.Scalar.UTF8View
UnsafeBufferPointer
UnsafeMutableBufferPointer
UnsafeMutableRawBufferPointer
UnsafeRawBufferPointer

这里列这么一大坨实在不是想吓跑各位天真的小伙伴们，只是单纯的想列出来而已~ 😦

除了最常用的 Array、Set 和 Dictionary 三个集合类型之外，我们还将介绍一个有趣的 Range 类型，使用它我们可以描述无限的大集合。

如果觉得上面这些集合类型"一个都不能打"，我们也可以自行动手创建自定义集合类型，你猜对了：就是遵守 Collection 协议即可！

由于篇幅所限，创建自定义集合的话题不在本文范围之内，有缘会在随后的博文中与大家相见。

2. 数组

数组（Array）是很常见的集合类型：

在 Swift 中数组其实就是一个遵守 Collection 协议的泛型结构。我们可以用多种方法来创建数组：

swift 复制代码

var ary0 = Array<Int>()
var ary1 = [Int]()
var ary2: [Int] = []

let ary3 = [Int](repeating: 0, count: 100)
let ary4 = [1,2,3,4,5]
let ary5 = Array((0..<100))

如上，我们变着花似地创建了 6 个整数（Int）数组，其中前三个是可变数组，后三个是不可变数组，或者称为只读数组。

我们可以在创建时为数组赋值，或者随后再动态插入新的元素：

swift 复制代码

var ary = [Int]()
for i in 0..<100{
    ary.append(i*i)
}

如果可能，还是尽量在数组创建时就"填满它"，这样会更具效率。而且在数组尾部新增元素比头部会快更多！

更多数组性能的优化秘技请大家参考如下链接：

我们可以在数组上应用多种方法：

swift 复制代码

let ary = Array((0..<100))
// 整数数组元素求和
let total = ary.reduce(0) { $0 + $1 }
// 将整数数组转换为字符串数组
let stringAry = ary.map {String($0)}

let neg_ary = -100..<0
// 组合两个数组
let zip_ary = zip(ary, neg_ary).map {[$0*$0, $1]}

因为在 Swift 语言中，数组被实现为结构而非类，由于结构的值拷贝特质：copy 后的数组和原数组就"再无瓜葛了，我们可以随心所欲的改变它而不影响前者：

swift 复制代码

var ary0 = [1,2,3]
var ary1 = ary0
ary1[0] = -1

print([ary0, ary1])
// 输出： [[1, 2, 3], [-1, 2, 3]]

不过，上面说的这种 copy 又称之为"浅拷贝"，这意味着如果数组元素为引用类型，那么它们的改变仍然会影响新旧两个数组，使用时请尤其留意：

在上面的代码中，我们改变了新数组中第一个元素的内容，原数组的对应元素也发生了改变。这是因为其元素的类型是 NSMutableString，它是一个引用类型。数组浅拷贝只是 copy 它们的引用，所以实际上它们的改变"所有人都逃不了干系"。

除了普通的数组以外，还存在一种"奇懒无比"的惰性数组：LazySequence。

其实它应该被称为"惰性序列"，因为它更像一种序列（Sequence）。其包含的每个元素都只在需要时才会被求值，我们会在随后介绍 Range 类型时对 LazySequence 做更进一步的说明。

3. 字典

聊完了数组之后，我们再来与字典（Dictionary）打声招呼吧:

字典是描述键值（Key-Value）对应关系的一种集合容器。从上面字典的定义中可以看到其键类型必须遵守 Hashable 协议。仔细想想也是蛮有道理的：如若不然，怎么区别字典中键的唯一性呢？

如您所愿，我们同样可以用各种千姿百态的"姿势"来创建字典：

swift 复制代码

let dict0 = ["A": 0xa, "B": 0xb, "C": 0xc]
var dict1 = [String: Int]()
var dict2: [String: Int] = [:]
var dict3 = Dictionary<String,Int>()

dict2["Panda"] = 11
dict2["Hopy"] = 121

与数组类似，我们可以轻松的遍历字典中的所有键和值：

swift 复制代码

let dict = ["A": 0xa, "B": 0xb, "C": 0xc]

for key in dict.keys {
    // 单独遍历所有键
}

for value in dict.values {
    // 单独遍历所有值
}

for (key,value) in dict {
    // 同时遍历键和值
    print("\(key):\(value)")
}

let total = dict.reduce("") {$0 + $1.key}

不过字典是无序的，所以不能期望遍历时它们的顺序保存稳定。实际上，依赖于字典元素间顺序的代码逻辑都是错误的，比如上面最后一行代码。

由于无法保证键一定有对应的值，所以通过字典键访问值的结果将会是一个可选类型，我们可以适时的为字典琢磨出一个默认值：

swift 复制代码

let dict = ["A": 0xa, "B": 0xb, "C": 0xc]

// value 的类型为 Int?
let value = dict["A"]
// 为字典设置默认值
let concreteValue = dict["Z"] ?? 0

总结

在上篇的学习中，我们讨论了 Swift 中集合背后的 Collection 协议，并随后介绍了数组（Array）和字典（Dictionary）两种集合类型。

在下篇中，我们将继续集合大冒险，探索更多的集合类型。

感谢观赏，再会！😎