Swift(二、集合)

---

1、Swift入门学习笔记（第一版），对Swift的基础知识点进行梳理总结。知识点一直在变，只是作为参考，以苹果官方文档为准~

2、在学习完基本的知识点以后会结合官方文档及相关资料，在此版本的基础上进行添加更改。

---

二、集合类

---

1、数组Array

数组中的集合元素是有序的，可重复出现

---

1.1、初始化

var array1:Array<String> = ["Zhu","Hu","Huang"]      //<String>是泛型，表示此数组只能存放字符串类型的数据
var array2:[String] = ["Zhu"]           //[String]与Array<String>等价
let array3:[String] = ["Zhu"]           //let声明不可变数组，必须同时进行初始化，初始化后不能修改
var array4 = [String]()                 //初始化空数组，限定值类型为String
var array5 = ["Zhu","Hu","Huang"]       //不写类型系统自动推断
var array6 = array1 + array2            //两数组相加创建数组
print(array6)
var repeatArray = [Double](count: 3, repeatedValue: 2.18)
print(repeatArray)      //初始化一个长度为3，元素均为2.18
var repeatArray1 = Array(count: 3, repeatedValue: 21.8)
print(repeatArray1)

Output：

["Zhu", "Hu", "Huang", "Zhu"]
[2.18, 2.18, 2.18]
[21.8, 21.8, 21.8]

注意点：
a、不可变数组在访问效率上比可变数组要高，可变数组通过牺牲效率换取可变。当可变数组内添加新元素的时候，数组要重新改变大小，然后重排其索引下标，影响性能。
b、var array2:[String]与[String]()的区别，前者语句声明没有初始化，未开辟内存空间。而后者进行初始化，只是没有任何元素
c、[String]与Array<String>等价
d、let声明不可变数组，必须同时进行初始化，初始化后不能修改
e、不写类型系统自动推断

---

1.2、基本操作

var countList:[String] = ["One","Two","Three"]
print("初始数组:\(countList)")

增加操作

//增加元素append
countList.append("Four")
print("增加后:\(countList)")

//增加insert
countList.insert("Zero", atIndex: 0)
print("Insert后:\(countList)")

//+=操作符
countList += ["Five","Six"]
print("+=操作后:\(countList)")

Output：

初始数组:["One", "Two", "Three"]
增加后:["One", "Two", "Three", "Four"]
Insert后:["Zero", "One", "Two", "Three", "Four"]
+=操作后:["Zero", "One", "Two", "Three", "Four", "Five", "Six"]

改操作

//替代(修改)
countList[0] = "数字0"
print("替代操作后:\(countList)")

Output：

替代操作后:["数字0", "One", "Two", "Three", "Four", "Five", "Six"]

改一系列操作

//countList[1...5] = ["数字1","数字2","数字3","数字4","数字5","数字6"]
//print("替代操作长度大于需要长度:\(countList)")
//替代操作长度大于需要长度:["数字0", "数字1", "数字2", "数字3", "数字4", "数字5", "数字6", "Six"]

countList[1...5] = ["数字1","数字2","数字3","数字4","数字5"]
print("替代操作后长度等于需要长度:\(countList)")
//替代操作后长度等于需要长度:["数字0", "数字1", "数字2", "数字3", "数字4", "数字5", "Six"]

//countList[1...5] = ["数字1","数字2","数字3","数字4"]
//print("替代操作后长度小于需要长度:\(countList)")
//替代操作后长度小于需要长度:["数字0", "数字1", "数字2", "数字3", "数字4", "Six"]

注意
把下标为1-5的元素改掉，后面修改的内容个数可以小于/等于/大于之前需要修改的个数，因此可能会改变数组的长度。但千万注意是不会影响其他下标位置的内容，只是在此range内长度变化

删操作

countList.removeLast()
print("remove最后一个元素后:\(countList)")

Output：

remove最后一个元素后:["数字0", "数字1", "数字2", "数字3", "数字4", "数字5"]

判断数组是否为空

if countList.isEmpty {
    print("Array is Empty")
}else {
    print("Array is Not Empty")
}

Output：

Array is Not Empty

数组长度

//获取数组长度
print("数组长度为\(countList.count)")
//容量为能容纳当前内容的最小长度（值的规律有待考究）
print("数组容量为\(countList.capacity)")

Output：

数组长度为6
数组容量为12

数组遍历

//数组的遍历
for item in countList {
    print(item)
}

//索引值和数值，enumerate()返回一个由每一个数据项索引值和数据值组成的元组
for (index,value) in countList.enumerate() {
    print("Item \(index+1) : \(value)")
}

Output：

数字0
数字1
数字2
数字3
数字4
数字5
Item 1 : 数字0
Item 2 : 数字1
Item 3 : 数字2
Item 4 : 数字3
Item 5 : 数字4
Item 6 : 数字5

---

2、集合Set

集合用来存储相同类型并且没有确定顺序的值。与数组不同，当集合元素顺序不重要或者确保每个元素值出现一次是使用集合

---

2.1、集合类型的哈希化

一个类型为了存储在集合中，该类型必须是可哈希化的-该类型必须提供一种方法计算它的哈希值，一个哈希值为Int类型，相等的对象哈希值必须相同。

a=b那么a.hashValue == b.hashValue

Swift的所有基本类型（形如String，Int，Double，Bool）默认是可哈希化的，可以作为集合的值的类型或者字典的键的类型。没有关联值的枚举成员值(在枚举有讲述)默认也是可哈希化的。

-

Swift可以自定义类型作为集合值或键的类型，但是要满足标准库中的Hashable协议，Hashable协议符合Equatable协议（自反性，对称性，传递性）

---

2.2、集合基本操作

集合的基本增删改查操作大致与数组相同

---

2.3、集合成员基本操作

let oddSets:Set = [1,3,5,7,9]
let evenSets:Set = [0,2,4,6,8]
let primeSets:Set = [2,3,5,7]

print(oddSets.union(evenSets).sort())           //组合
print(oddSets.intersect(evenSets).sort())       //交集
print(oddSets.subtract(primeSets).sort())       //不在该集合中的值
print(oddSets.exclusiveOr(primeSets).sort())    //该集合除去交集且除去另一集合值

Output：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[]
[1, 9]
[1, 2, 9]

---

2.4、集合之间关系

let testSet1:Set = [1,2]
let testSet2:Set = [1,2,3]
let testSet3:Set = [4,5]
let testSet4:Set = [1,2]

print(testSet1 == testSet4)                 //判断1，4是否包含全部相同值
print(testSet1.isSubsetOf(testSet2))        //判断1是否被包含在2中
print(testSet2.isSupersetOf(testSet1))      //判断2是否包含1
print(testSet1.isStrictSubsetOf(testSet2))  //多个个Strict时多了个两集合不相等的条件
print(testSet1.isStrictSupersetOf(testSet4))
print(testSet2.isDisjointWith(testSet3))    //判断两集合是否无交集

Output：

true
true
true
true
false
true

---

3、字典Dictionary

---

3.1、初始化

let不可变-声明时必须同时初始化，不可修改；var可变

var Dic1 = [:]
var Dic2 = Dictionary<String,Int>()   //声明一个空的字典，key的集合为String类型，value的集合为Int类型
let Dic3 = ["name":"Zhu","age":21]
var InfoDic:Dictionary<String,String> = ["name":"Zhu","age":"21"]
print(InfoDic)

Output：

["age": "21", "name": "Zhu"]

---

3.2、基本操作

添加/修改操作

会在字典中查找key对应的value，如果有key修改对应的value，如果没有该key就增加key-value

InfoDic["name"] = "Zane"
print(InfoDic)

InfoDic["sex"] = "Man"
print(InfoDic)

InfoDic.updateValue("NCZ", forKey: "name")
print(InfoDic)

Output：

["age": "21", "name": "Zane"]
["age": "21", "sex": "Man", "name": "Zane"]
["age": "21", "sex": "Man", "name": "NCZ"]

删除操作

InfoDic["sex"] = nil
print(InfoDic)

InfoDic.removeValueForKey("age")
print(InfoDic)

Output：

["age": "21", "name": "NCZ"]
["name": "NCZ"]

键值对个数

print("Dic count is " + String(InfoDic.count))

Output：

Dic count is 1

遍历

var dormDic:Dictionary<String,String> = ["dorm1":"Zhu","dorm2":"Zheng","dorm3":"Fu"]
//遍历
//键值遍历
for (dormNum,dormName) in dormDic {
    print("\(dormNum) : \(dormName)")
}

//值遍历/键遍历
for value in dormDic.values {
    print("寝室成员名字:\(value)")
}

for key in dormDic.keys {
    print("寝室成员编号:\(key)")
}

Output：

dorm1 : Zhu
dorm2 : Zheng
dorm3 : Fu
寝室成员名字:Zhu
寝室成员名字:Zheng
寝室成员名字:Fu
寝室成员编号:dorm1
寝室成员编号:dorm2
寝室成员编号:dorm3

提取所有values(keys相同)

let allValues = Array(dormDic.values)
print(allValues)

Output：

["Zhu", "Zheng", "Fu"]