Swift编程语言中常用的三种收集类型（collection type），分别为：数组（Array）、集合（Set）和字典（Dictionary）.这些类型都属于结构体类型，并且都是以泛型的形式定义的.

• 倘若我们使用 var来声明一个收集类型的变量对象，那么该收集对象是以可修改的方式创建的，可以对该收集类型对象做元素添加、删除、修改等操作。
• 如果我们用let来声明一个收集类型的常量对象，那么我们此对象不仅不能改变它的值，也不能对其元素做添加、修改、删除等操作。
• 如果我们断定不会对一个收集类型的对象做任何修改操作，那么应该对它声明为常量，这会使编译器对它的元素访问做更好的优化。

数组

数组是一个可以存放相同类型的多个元素对象的有序线性列表，这些元素对象可以是任意类型，包括元组也没有问题。但是如果在一个数组中出现了与其他元素类型不同的元素，那么编译器会直接报错。
一个数组的完整类型为：Array<Element>。这里的 Element 即表示当前数组对象存放的元素类型，可以是任意类型。如果我们要声明一个元素为 Int 的数组，那么可以使用 Array<Int>。此外，数组还有一种精简表示法：[Element]。比如，声明一个元素为 Int 的数组也可以用 [Int]。
我们可以用 Array 的构造方法创建一个空数组，也可以创建一个指定元素个数的数组，比如：

// 声明一个Array<Int>类型的数组对象array，
// 并对它创建一个空数组
var array = Array<Int>()
 
// 我们也可以使用[Int]的精简数组类型表示
// 这里声明了一个[Int]类型的数组对象r，
// 并对它创建了一个空数组
let r = [Int]()
// 这里声明了一个[Double]类型常量数组，
// 并创建了10个元素，每个元素都是3.0
let a = [Double](repeating: 3.0, count: 10)
 
// 这里声明了一个[(Int, Double)]类型的常量数组b，
// 并创建了5个元素，每个元素都是(1, 0.5)
let b = [(Int, Double)](repeating: (1, 0.5), count: 5)

不过我们更常用的是直接使用数组的字面量。比如：[1, 2, 3, 4, 5] 表示一个包含5个 Int 类型对象的数组，该数组的类型就是 [Int]。数组字面量中除了可以存放整数、浮点数等字面量之外，还能存放其他常量和变量。我们看以下代码：

// 声明一个数组常量a，
// 它具有4个Double类型对象元素
let a = [0.5, 1.0, 1.5, 2.0]
 
var x = 1, y = 2
 
let z = 3, w = 4
 
// 声明了一个数组常量b，
// 它具有4个Int类型对象元素
let b = [x, y, z, w]
// 这里通过空的数组字面量来创建一个空数组，
// 这里需要给数组常量c显式指定类型
let c: [Int] = []

Swift中还提供了 + 操作符，可以把两个数组对象拼接在一起，构成一个新的数组。比如以下代码：

/// 这里将[1, 2, 3]与[4, 5, 6]两个数组进行拼接，
/// 然后构造出一个[Int32]类型的数组对象给常量a
let a: [Int32] = [1, 2, 3] + [4, 5, 6]
 
// 数组变量b现在具有[true, false, true]三个元素
var b = [true, false, true]
 
// 对于变量数组，可以使用+=为它自己添加新的元素，
// 不过+=后面必须是与它相同类型的数组，
// 不能是元素类型对象。
b += [false, false]
 
// 此时b的元素为：
// [true, false, true, false, false]
print("b = \(b)")

数组对象的元素访问

访问数组的指定元素直接通过下标操作符（subscript operator） []即可，下标中存放指定元素索引的整数对象表达式。数组第一个元素的索引为0。我们可以将一个负整数作为下标操作符中的索引值，不过一般情况下这会引发程序异常，但它或许能用于其他特殊场合，比如我们在自己的结构体或类中自定义下标操作符的行为。如果我们要访问一个数组元素，指定的索引值超出了数组本身的大小，那么程序会引发异常。下面我们来看一些代码例子：

let a = [1, 2, 3, 4, 5]
 
// 这里读取数组a的索引0的元素，
// 即第一个元素，并为常量x初始化
let x = a[0]
 
// 这里读取数组a的索引2的元素，
// 即第三个元素，并为常量y初始化
let y = a[2]
 
var b = [1.0, 2.0, 3.0]
 
// 这里修改数组变量b的索引1的元素，
// 即第二个元素
b[1] += 0.5
 
// 这里要访问的是数组b的索引3的元素，
// 即第四个元素，由于数组b总共只有3个元素，
// 因此超出了数组b的范围，这会导致异常
b[3] = 0.0

下标操作符属于单目后缀操作符，它只有一个操作数。其操作数就是跟在它之前（即左侧）的后缀表达式，而下标中的表达式则不是它的操作数，这点请各位注意。此外，只有遵循了 Collection 协议的类型对象才能作为下标操作符的操作数。
我们要判定一个数组包含了多少个元素，可以使用 count 属性，它是一个 Int 类型的只读属性。如果我们仅仅只是判断当前数组是否为空（这里的空表示当前数组不包含任何元素，而不是空值），那么可以使用 isEmpty 属性，它是一个 Bool 类型。如果我们要判定一个数组中是否存在某一元素的值，可以使用 contains(:) 实例方法。该方法具有一个 Element 类型参数用于指定元素对象，如果当前数组至少有一个元素的值与指定元素的值相同，那么返回真，否则返回假。
然后，对于一个变量数组，我们还可以使用 append(:) 实例方法为变量数组在最后添加一个新的元素。使用 insert(_:at:) 实例方法在指定索引位置插入一个新的元素，原本在此索引位置的元素将被移动到新元素的后边。使用 remove(at:) 实例方法移除指定索引位置的元素。下面我们举一些例子：

let a = [1, 2, 3, 4, 5]
// 访问常量数组a的count属性
print("count of a: \(a.count)")
 
// 访问常量数组a的isEmpty属性
print("is Empty? \(a.isEmpty)")
 
// 判定数组a是否含有元素2
print("contain 2? \(a.contains(2))")
 
// 判定数组a是否含有元素0
print("contain 0? \(a.contains(0))")
 
var b = [1.0, 2.0, 3.0]
 
// 在变量数组b后面添加新元素4.0
b.append(4.0)
 
// 在索引2位置处插入元素2.5，
// 此时数组b中的元素有：[1.0, 2.0, 2.5, 3.0, 4.0]
b.insert(2.5, at: 2)
 
// 移除索引位置1的元素
b.remove(at: 1)
 
// 输出当前数组b的内容
print("b = \(b)")

数组字面量（比如：[1, 2, 3, 4, 5]）本身是一个常量，如果我们对数组字面量直接调用 append(_:) 等具有元素修改的实例方法，则会引发编译器报错。