Swift3-集合类型

一、引言

Swift中提供了3种集合类型，Array数据类型，Set集合类型，Dictionary字典类型。

Array用于存放一组有序的数据，数据角标从0开始一次递增；
Set用于存放一组无序的数据，数据不可以重复；
Dictionary也用于存放一组无序的数据，只是其是按照键值对的方式存储，键值必须唯一。

这里借用官方文档中的一张图来表示3种集合类型的特点：

二、Array类型

Array通常也被称为数组，Swift是一种类型安全语言，其中的Array类型也必须确定其元素的类型，声明数组类型有两种方法，示例如下：

//将数组声明为Int类型值集合的数组
var array1:[Int]
var array2:Array<Int>
//创建空数组
array1 = []
array2 = Array()

数组对象如果通过var变量也接收，则其为可变的数组，可以通过append方法来追加元素，示例如下：

//向数组中追加元素
array1.append(3)    //[3]

在创建数组时，也可以对数组进行初始化，示例如下：

//创建数组[0,0,0]
var array3 = [Double](repeating: 0, count: 3)
//创建数组[2.5,2.5,2.5]
var array4 = Array(repeating: 2.5, count: 3)
//数组可以使用+号直接进行追加 [0,0,0,2.5,2.5,2.5]
var array5 = array3+array4

Swift中提供了许多访问和修改数组的方法，示例代码如下：

//获取数组中元素个数
array5.count    //6
//判断数组是否为空
array5.isEmpty  //false
//判断数组是否包含某个元素，有则返回所包含的元素个数
array5.index(of: 1);    //nil
array5.index(of: 2.5);  //3

//通过下标访问数组中的元素
array5[1]   //0

//通过下标修改数组元素
array5[1]=2 //2
//修改数据中的一组数据
array5[0...3] = [1,1]   //[1, 1, 2.5, 2.5]

//替换数据中的一组数据，作用与修改一样
array5.replaceSubrange(Range(1..<2), with: [66,77,88,99]) //[1, 66, 77, 88, 99, 2.5, 2.5]

//向数组中某个位置插入一个数据
array5.insert(3, at: 1) //[1, 3, 66, 77, 88, 99, 2.5, 2.5]

//移除数组某个角标处的元素
array5.remove(at: 1)    //[1, 66, 77, 88, 99, 2.5, 2.5]

//移除数组的最后一个元素
array5.removeLast() //[1, 66, 77, 88, 99, 2.5]

//移除数组第一个元素
array5.removeFirst()    //[66, 77, 88, 99, 2.5]

//遍历整个数组
for item in array5 {
    print(item)
}
//遍历数组枚举
for (index,item) in array5.enumerated() {
    print(index,item)
}
//移除数组所有元素
array5.removeAll()  //[]

三、Set类型

Set类型集合不关注元素的顺序，但是其可以保证其中元素的唯一性。和Array类型一样，Set类型来声明时也需要确定其内元素的类型，示例如下：

var sets1 = ["qwe","asd","zxc"] //["qwe", "asd", "zxc"]
type(of:sets1)  //Array<String>.Type
//Set类型不能从数组字面量中被单独推断出来，因此Set类型必须显式声明,但是可以不声明具体类型,具体类型可以自检
var sets2: Set = ["qwe","asd","zxc"]    //{"zxc", "qwe", "asd"}
type(of:sets2)  //Set<String>.Type

下面示例代码演示对集合进行操作：

var set1:Set<Character> = ["a","b","c","d"]
//向集合中插入元素
set1.insert("z")    //(.0 true, .1 "z") 返回值中true表示成员不重复，插入成功
set1    //{"b", "a", "d", "c", "z"}
set1.insert("z")    //(.0 false, .1 "z") 返回值中false表示成员重复，插入失败

//获取集合中元素个数
set1.count  //5
//判断集合是否为空
set1.isEmpty    //false
//判断集合中是否包含某个元素
set1.contains("e")  //false
//将集合中的某个元素移除
set1.remove("a")    //{"b", "d", "c", "z"}

//遍历集合
for item in set1 {
    print(item)
}
//进行从小到大的排序遍历
for item in set1.sorted() {
    print(item)
}

//移除集合中的所有元素
set1.removeAll()    //Set([])

Set也支持进行一些集合的数学运算，例如交集，并集，补集等，下面一张图演示了Set进行集合运算的一些特性：

- intersection(_:) 交集,根据两个集合中都包含的值 创建 的一个新的集合。
- symmetricDifference(_:) —> 交集的补集,根据在一个集合中但不在两个集合中的值 创建 一个新的集合。
- union(_:) —> 并集,根据两个集合的值 创建 一个新的集合。
- subtracting(_:) —> 第二个集合的补集,在第一个集合中 根据不在第二个集合中的值 创建 一个新的集合。
- subtract(_:) —> 第二个集合的补集,并且从第一个集合中移除交集的元素。没有返回值！

示例代码如下：

let sets10: Set = [1, 2, 3, 4, 5, 6]
var sets11: Set = [4, 5, 6, 7, 8]


//交集
let set01 = sets11.intersection(sets10) //返回{4, 5, 6},sets11和sets10值不变
sets11
sets10

//交集的补集
let set02 = sets11.symmetricDifference(sets10)  //返回{1, 2, 3, 7, 8},sets11和sets10值不变

//并集
let set03 = sets11.union(sets10)   //返回{1, 2, 3, 4, 5, 6, 7, 8},sets11和sets10值不变

//第二个集合的补集
let set04 = sets11.subtracting(sets10)  //返回[7, 8],sets11和sets10值不变
sets11

//第二个集合的补集,并且从第一个集合中移除交集的元素。没有返回值
sets11.subtract(sets10)  // sets11的值变为[7, 8] 和 sets10值不变
//let set05:Set<Int> = sets11.subtract(sets13)  //错误，subtract没有返回值！
let set05 = sets11  //[7, 8]

• “相等”运算符 ( == ) —> 判断两个集合是否相等；
• isSubset(of:) —> 判断第一个集合是否是第二个集合的子集；
• isSuperset(of:) —> 判断第一个集合是否是第二个集合的超集，即第一个集合是否包含第二个集合的所有值；
• isStrictSubset(of:) —> 判断是否是某个集合的真子集，即这个集合是某一个集合的子集，但它们并不相等；
• isStrictSuperset(of:) —> 判断是否是某个集合的真超集，即这个集合是某一个集合的超集，但它们并不相等；
• isDisjoint(with:) —> 判断两个集合是否没有相同的值。没有相同的值则返回true，有则false。

下面代码显示了与子集相关的运算：

sets11 = [4, 5, 6, 7, 8]
let sets12: Set = [4, 6, 8]
let sets13: Set = [4, 5, 6, 7, 8]
let sets14: Set = [1, 3, 5, 7, 9]

//判断是否相等
sets11 == sets12    //false
sets11 == sets13    //true

//判断第一个集合是否是第二个集合的子集
sets11.isSubset(of: sets12) // false
sets12.isSubset(of: sets11) // true

//判断第一个集合是否是第二个集合的超集
sets11.isSuperset(of: sets12)   // true
sets12.isSuperset(of: sets11)   // false

//判断是否是某个集合的真子集，
sets12.isStrictSubset(of: sets11)   //true
sets13.isStrictSubset(of: sets11)   //false

//判断是否是某个集合的真超集
sets11.isStrictSuperset(of: sets12) //true
sets11.isStrictSuperset(of: sets13) //false

//判断两个集合是否没有相同的值，没有则返回true
sets11.isDisjoint(with: sets12)// false
sets12.isDisjoint(with: sets14)// true

四、Dictionary类型

Swift中的Dictionary在声明时必须明确键的类型和值的类型，示例如下：

var dic:Dictionary<Int,String>
var dic1:[Int:String] = [1:"one",2:"Two"]

访问与操作Dictionary的方法，代码示例如下：

var dic2:[Int:String] = [1:"One",2:"Two",3:"Three",4:"Four"]
//获取字典键值对个数
dic2.count  //4
//判断字典是否为空
dic2.isEmpty    //false
//通过键获取值
dic2[1] //"One"

//添加或修改: 字典变量[键] = 值
//通过键修改值
dic2[1] = "First"   //[2: "Two", 3: "Three", 1: "First", 4: "Four"]
//添加键值
dic2[0] = "Zero"    //[0: "Zero", 2: "Two", 3: "Three", 1: "First", 4: "Four"]


//updateValue 方法将更新一个键值 如果此键存在 则更新键值 并且将旧的键值返回 如果此键不存在 则添加键值 返回nil 其返回的为一个Optional类型值 可以使用if let进行处理
dic2.updateValue("9", forKey: 1)    //"First"
//使用if let 处理updateValue的返回值
if let oldValue = dic2.updateValue("One", forKey: 1) {
    print("Old Value is \(oldValue)")   //"Old Value is 9\n"
}
//通过键值获取的数据也将是有个Optional类型的值 也可以使用if let
if let value = dic2[1] {
    print("The Value is \(value)")  //"The Value is One\n"
}

//如果有此键，则移除某个键值对
dic2    //[0: "Zero", 2: "Two", 3: "Three", 1: "One", 4: "Four"]
dic2[9]=nil //没有此键，忽略
dic2[0]=nil //[2: "Two", 3: "Three", 1: "One", 4: "Four"]
//如果有此键，则返回其值，并移除键值对,没有则返回nil
dic2.removeValue(forKey: 0) //没有此键，忽略
dic2.removeValue(forKey: 1) //返回“One”，dic2变为[2: "Two", 3: "Three", 4: "Four"]


//对字典进行遍历
for (key,value) in dic2 {
    print(key,value)
}
//遍历所有键
for key in dic2.keys {
    print(key)
}
//遍历所有值
for value in dic2.values {
    print(value)
}
//进行从小到大的排序遍历
for key in dic2.keys.sorted() {
    print(key)
}

原文https://my.oschina.net/u/2340880/blog/673359，仅针对swift3做少量更改。