集合

集合的定义

Swift中提供了两种数据结构用于存放数据的集合，分别是数组（Array）和字典（Dictionary）。他们的主要区别在于数组中的元素由下标确定，而字典中的数据的值由数据的键（Key）决定。以下我们认为集合就是数组或字典。

集合的可变性

我们可以定义一个集合常量或者集合变量。一旦定义为常量，就意味着集合的长度、内容和顺序都不能再修改了。比如，定义为常量的数组，不能再向其中添加新的元素。

数组的创建

由于swift中变量的创建遵循“ var 变量名：变量类型 ”的语法，因此数组的创建归根结底还是数组类型的定义。一共有三种方法来定义数组的类型：

var arrayOne:Array<Int> = [1,2,3]
println("arrayLong = \(arrayOne)")

var arrayTwo:[Int] = [1,2,3]
println("arrayShort = \(arrayTwo)")

var arrayThree = [1,2,3]
println("arrayThree = \(arrayThree)")

第一种是数组类型的完整定义，即Array关键字加上一对尖括号，括号内写上数组元素的类型。

第二种是数组类型的简化定义，即一对方括号内写上数组元素的类型。这与第一种定义方法完全等价。

在使用这两种方法定义数组的时候，一定要确保数组中每个元素类型相同，否则将会产生编译错误。

第三种运用了Swift的类型推导的特性。需要注意的是，数组的值由方括号组成，里面的元素用逗号隔开。如果方括号改成了圆括号，编译器不会报错（这将变成元组），所以千万要小心，避免莫名其妙的错误。

第三种方法除了书写简单之外，还有一种好处，即不必确保数组中每个元素类型相同。我们来通过代码看一看多个不同类型的元素出现在统一数组中会发生什么情况：

var arrayThree = [1,2,3]
println("arrayThree = \(arrayThree)")

var arrayMixed = [1,"abc",true, 1.5]
println("arrayMixed = \(arrayMixed)")//在这一行结束前设置断点
//在LLDB调试其中分别输入print arrayThree和print arrayMixed

可以得到如下结果

([Int]) $R0 = 3 values {
  [0] = 1
  [1] = 2
  [2] = 3
}

([NSObject]) $R1 = 4 values {
  [0] = 0x0000000000000137 Int64(1)
  [1] = "abc"
  [2] = 0x00007fff7255e8a8 {
    NSNumber = {
      NSValue = (null)
    }
  }
  [3] = 0x00000001006008a0 {
    NSNumber = {
      NSValue = (null)
    }
  }
}

因此不难发现，arrayMixed数组之所以可以添加多个类型的元素，是因为它被推导为Array< NSObject>类型。同样的，所以一旦数组的类型确定，就不能再插入不属于这个类型的的值。

在我阅读的教材上，作者特别提出，不指定类型的数组不能使用Array的append方法。但是经过我的测试，并没有这样的限制。有兴趣的读者可以自行测试，欢迎指正。

数组的访问与修改

数组长度

可以使用数组的只读属性count来获取数组长度：

var arrayThree = [1,2,3]
println("arrayThree.count = \(arrayThree.count)")

判断数组为空

可以使用数组的只读属性isEmpty来判断数组是否为空，当然通过判断count是否为0也可以达到同样的效果，不过代码略长一些。

var arrayThree = [1,2,3]
if !arrayThree.isEmpty{
    println("Array Three is not empty")
}

添加新元素

一共有两种方法可以在数组的尾部添加新元素：

//方法一，使用数组的append函数
var arrayThree = [1,2,3]
arrayThree.append(4)
println("arrayThree = \(arrayThree)")

//方法二，使用加法运算符
var arrayThree = [1,2,3]
arrayThree += [4]
println("arrayThree = \(arrayThree)")

无论使用哪种方法，都必须保证新添加的元素和数组类型相同。比如试图像arrayThree中添加元素’1.5’会导致编译错误。

可以看到，第二种方法的本质实际上是在两个数组对象之间调用加法运算符，得到的结果是两个数组拼接之后的结果。因此，第二种方法具有一个强大的功能，即向数组尾部添加多个元素。

还有一种通用的方法，即调用数组的insert（atIndex：）方法，在指定位置插入新元素。

var arrayThree = [1,2,3]
arrayThree.insert(4, atIndex: 2)
println("arrayThree = \(arrayThree)")

删除数组元素

可以调用数组的removeAtIndex()和removeLast()方法。

var arrayThree = [1,2,3]
var numberThree = arrayThree.removeAtIndex(2)
var numberTwo = arrayThree.removeLast()

这两个方法会返回被删除的元素的值，当然如果不需要知道，可以无视它的返回值，直接调用方法即可。

需要注意的一点是，removeAtIndex方法首先要判断下标是否越界，也就是说它会用到数组的长度。这意味着需要线性遍历数组，因此如果只需要移除数组的最后一个元素且数组长度很大时，应该使用removeLast()方法。

访问数组元素

了解了如何添加和删除元素，我们就要想办法把新加入的元素取出来看看了。通过数组下标可以访问指定位置的数组元素，语法与C语言相同。

var arrayThree = [1,2,3]
println("ArrayThree[2] = \(arrayThree[2])")

修改数组元素

下标不仅可以访问数组元素，还可以实现数组元素的修改。这和访问数组元素是非常类似的，只要交换等号两边变量的位置即可。

var arrayThree = [1,2,3]
var secondInt = arrayThree[1] //访问元素

var newSecond = 4
arrayThree[2] = newSecond //修改数组元素

不仅如此，还可以通过数组下标批量修改元素：

var arrayThree = [1,2,3]
var firstNumber = 1
var secondNumber = 2
arrayThree[0...1] = [firstNumber,secondNumber]

此时，等号的右侧必须是数组的字面量，而不能是一个数组变量。也就是说这样的写法是错误的：

var arrayThree = [1,2,3]
var newArray = [3,4]
var newSlice: ArraySlice<Int> = [3,4]
arrayThree[0...1] = newArray //错误。
arrayThree[0...1] = newSlice //正确

原因是左边的arrayThree[0…1]其实是一个SubArray，在Swift中它的类型叫做ArraySlice，即Int类型的数组切片，而右边是一个Array类型变量，根据Swift类型安全的特性，这样的操作自然是被禁止的。

如果左边的切片长度和右边的变量长度不一致会发生什么情况呢？不用过于担心，这不会产生任何错误。Swift会机智的帮我们解决这个问题。

var arrayOne:[Int] = [1,2,3]
var arrayTwo = [1,2,3]
var sliceOne:ArraySlice<Int> = [1,2,3]
var sliceTwo:ArraySlice<Int> = [1]
arrayOne[1...2] = sliceOne
arrayTwo[1...2] = sliceTwo
println("arrayOne = \(arrayOne)")
println("arrayTwo = \(arrayTwo)")

输出结果分别是：

arrayOne = [1, 1, 2, 3]
arrayTwo = [1, 1]

因此，如果变量长度超过切片长度，将会自动在切片位置后添加元素（如同arrayOne），相当于调用了数组的insert（atIndex：）方法若干次。同样地，如果变量长度少于切片长度，没有值的位置的元素自动被移除，后面的元素自动向前补上。相当于调用了数组的removeAtIndex（）方法若干次。

虽然这样不会出现任何错误，不过出于逻辑严谨性考虑，应该避免等号两端变量长度不一样的情况。

数组遍历

之前我们介绍了数组的增删改操作，还缺少一个查找。也就是数组的遍历。在Swift中，除了像C语言那样定义一个下标变量，在for循环中遍历数组，还有两种方式遍历数组。

//方法一，使用for in循环快速遍历
var array = [1,2,3,2,1,32,99]
for number in array{
    println("number = \(number)")
}

通过观察输出结果可以发现，for in循环是按照从前向后的顺序遍历数组的。

//方法二：使用enumerate函数
var array = [1,2,3,2,1,32,99]
for (index, value) in enumerate(array){
    println("value = \(value)")
}

enumerate(array)方法的返回值是一个数组。数组中的每一个元素都是一个二元元组。第一个值是下标index，第二个值是元素的值。这种方法也是顺序遍历数组。

数组的初始化

在本章的开头，我们利用数组字面量来初始化一个数组。其实，数组还有其他的初始化方法。

首先类比字符串的构造方法var string = String()，我们可以得知数组的另外两种构造方法。

var arrayOne = [Int]()
var arrayTwo = Array<Int>()
println("第一个数组元素个数为：\(arrayOne.count)")
println("第二个数组元素个数为：\(arrayTwo.count)")

运行结果：

第一个数组元素个数为：0
第二个数组元素个数为：0

除此以外，数组还有一种特殊的构造方法，可以指定数组长度，在这种情况下还必须强制指定数组中每个元素的值。如果觉得没用的话，可以先设置为0，然后再修改。

var arrayThree = [Int](count: 5, repeatedValue: 0)
var arrayFour = Array<Int>(count: 5, repeatedValue: 0)
var arrayFiver = Array(count: 5, repeatedValue: 0)
print("第三个数组为：\(arrayThree)")
print("第四个数组为：\(arrayFour)")
print("第五个数组为：\(arrayFiver)")

得益于类型推导，第五种数组初始化方法也是合法的。但是之前的标准初始化方法不可以这么简化。输出结果如下：

第三个数组为：[0, 0, 0, 0, 0]
第四个数组为：[1, 1, 1, 1, 1]
第五个数组为：[2, 2, 2, 2, 2]

附录

查看完整专栏——《Swift轻松入门》

【Swift入门（一）——基本语法】

【Swift入门（二）——字符与字符串】

【Swift入门（三）——元组（Tuple）】

【Swift入门（四）——可选类型（Optionals）与断言（Assert）】

【Swift入门（五）——数组（Array）】

版权声明：本文为博主原创文章，未经博主允许不得转载。