在Swift中集合类型有三种Arrays、Dictionarys、Sets三种,
1.
Array是有序数据的集，数据可以重复；
2.Dictionary是无序键值的集合；
3.Set是无序数据的急，可以重复。
在这三种集合类型中，数据的存储类型必须明确，可以防止我们插入错误类型的值，也能确保我们我们取出的值的正确性。此外，我们可以通过var或let创建可变集合或不可变集合。
数组Array
创建数组的基本形式Array<Element>，Element是数组中确定的元素类型，也可以使用[Element]的简单样式。
为了方便以后添加数组，下面都使用var来创建可变数组。
一、数组的几种创建方法
1.创建一个空数组,形式：var arrayName = [ArrayType]()，使用如下
var arr01 = [String]()
print(arr01.count)//0
当然，也可以使用var arrayName:[ArrayType] = []的形式
2.创建一个带有默认值的数组，形式：var arrayName = Array.init(repeating: <Element>, count: <Int>),如下
var arr02 = Array.init(repeating: "xxoo", count: 5)//会自动推断为String类型
print("\(arr02)")//输出结果：["xxoo", "xxoo", "xxoo", "xxoo", "xxoo"]
3.通过+操作符来创建数组，如下
arr01.append("py")
arr02.remove(at: 0)
var arr03 = arr01 + arr02
print("\n\(arr03)")//["py", "xxoo", "xxoo", "xxoo", "xxoo"]
注意，如果把不同类型数组进行+操作来创建新数组，是会提示错误的。
二、数组的访问和修改
具体的看代码操作
//count属性来获取数组中的元素个数
print("-01-Elements count = \(arr03.count)")//5
//通过isEmpty判断数组元素个数是否为0
print("-02-Elements count = \(arr03.isEmpty == true ? 0:arr03.count)")//Elements count = 5
//通过 ‘+=’ 操作添加新元素(具有相同类型的数据项)
arr03 += ["first，second"]
print("-03-Elements = \(arr03)")
//通过append操作来添加新元素(具有相同类型的数据项)
arr03.append("third")
print("-04-Elements = \(arr03)")
//改变数组中某个元素的值
arr03[0] = "dog"
print("-05-Elements = \(arr03)")
//改变数组中某个范围内数组的值
arr03[2...4] = ["keys01","keys02","keys03"]
print("-06-Elements = \(arr03)")
//删除指定位置的元素
arr03.remove(at: 0)
print("-07-Elements = \(arr03)")
//移除最后一项
arr03.removeLast()
print("-08-Elements = \(arr03)")
//移除第一项
arr03.removeFirst()
print("-09-Elements = \(arr03)")
//在某个位置插入元素
arr03.insert("pyl", at: 3)
print("-10-Elements = \(arr03)")
//在某个位置之后插入元素
arr03.insert("lgd", at: arr03.index(after: 0))
print("-11-Elements = \(arr03)")
//在某个位置之前插入元素
arr03.insert("godv", at: arr03.index(before: 1))
print("-12-Elements = \(arr03)")
运行结果
-01-Elements count = 5
-02-Elements count = 5
-03-Elements = ["py", "xxoo", "xxoo", "xxoo", "xxoo", "first，second"]
-04-Elements = ["py", "xxoo", "xxoo", "xxoo", "xxoo", "first，second", "third"]
-05-Elements = ["dog", "xxoo", "xxoo", "xxoo", "xxoo", "first，second", "third"]
-06-Elements = ["dog", "xxoo", "keys01", "keys02", "keys03", "first，second", "third"]
-07-Elements = ["xxoo", "keys01", "keys02", "keys03", "first，second", "third"]
-08-Elements = ["xxoo", "keys01", "keys02", "keys03", "first，second"]
-09-Elements = ["keys01", "keys02", "keys03", "first，second"]
-10-Elements = ["keys01", "keys02", "keys03", "pyl", "first，second"]
-11-Elements = ["keys01", "lgd", "keys02", "keys03", "pyl", "first，second"]
-12-Elements = ["godv", "keys01", "lgd", "keys02", "keys03", "pyl", "first，second"]
三、数组的遍历
1.不需要索引值的遍历
for item in arr03
{
print("Element = \(item)")
}
运行结果
Element = godv
Element = keys01
Element = lgd
Element = keys02
Element = keys03
Element = pyl
Element = first，second
2.需要索引值的遍历，当我们需要array中元素的索引值时，可以通过array对象来调用enumerated()方法，它返回的是索引值和元素组成的元组，如下
for (index,item) in arr03.enumerated()
{
print("Element index = \(index) ,value = \(item) ")
}
运行结果
Element index = 0 ,value = godv
Element index = 1 ,value = keys01
Element index = 2 ,value = lgd
Element index = 3 ,value = keys02
Element index = 4 ,value = keys03
Element index = 5 ,value = pyl
Element index = 6 ,value = first，second
集合Set
集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次 时可以使用集合而不是数组。
一个类型存储在集合中，该类型必须是可哈希化的--也就是说，该类型必须提供一个方法来计算它的哈希值。哈希值是Int类型的，相等的对象哈希值必须相同，比如a==b,因此必须a.hashValue == b.hashValu e。
Swift的所有基本类型(比如String,Int,Double和Bool)默认都是可哈希化的，可以作为集合的值的类型或 者字典的键的类型。没有关联值的枚举成员值默认也是可哈希化的。
一、集合的创建
如下，
//创建一个空集合
var collective = Set<Int>()
print("\(collective.isEmpty == true ? "集合为空":"集合的元素数量为:\(collective.count)")")
print("集合的类型推断为:\(type(of: collective))")
//通过数组字面量来创建集合
var arrayCollective:Set<Int> = [123,456,789]
print("-01-集合元素为:\(arrayCollective) ，数量：\(arrayCollective.count)个")
//通过空的数组字面量来创建空集合
arrayCollective = [];
print("-02-集合元素为:\(arrayCollective) ，数量：\(arrayCollective.count)个")
控制台输出
集合为空
集合的类型推断为:Set<Int>
-01-集合元素为:[456, 123, 789] ，数量：3个
-02-集合元素为:[] ，数量：0个
Program ended with exit code: 0
说明，在var collective = Set<Int>()中集合对象collective的类型被推断为Set<Int>类型，集合里面只能存放Int类型的数据元素。在var arrayCollective:Set<Int> = [123,456,789]中arrayCollective被显式指定为Set<Int>类型，[123,456,789]是它的初始化值。
二、集合的遍历访问与修改
1.集合的访问与修改
//插入一个元素
arrayCollective.insert(1129)
print("-03-集合元素为:\(arrayCollective) ，数量：\(arrayCollective.count)个")
//移除一个元素值
arrayCollective.remove(789)
print("-04-集合元素为:\(arrayCollective) ，数量：\(arrayCollective.count)个")
arrayCollective.removeFirst()
print("-05-集合元素为:\(arrayCollective) ，数量：\(arrayCollective.count)个")
//移除所有的元素值
arrayCollective.removeAll()
print("-06-集合元素为:\(arrayCollective) ，数量：\(arrayCollective.count)个")
arrayCollective = [11,22,33,44,55,66,77,88,99,00]
//判断是否包含某一个元素值
print("集合\(arrayCollective.contains(77) == true ? "包含":"不包含") \(77) 这个元素对象")
2.集合的遍历
无序遍历，输出的结果是无序的，如下
//无序遍历
for item in arrayCollective
{
print("EleValue = \(item)", separator: "", terminator: "\n")
}
运行结果
EleValue = 22
EleValue = 88
EleValue = 77
EleValue = 55
EleValue = 44
EleValue = 66
EleValue = 99
EleValue = 0
EleValue = 11
EleValue = 33
特定顺序遍历，由于集合中的元素是无序的，当我们想获取一定的顺序时，就可以访问它的sorted()方法，如下，
//按照特定顺序的遍历
for item in arrayCollective.sorted()
{
print("EleSortValue = \(item)", separator: "", terminator: "\n")
}
运行结果
EleSortValue = 0
EleSortValue = 11
EleSortValue = 22
EleSortValue = 33
EleSortValue = 44
EleSortValue = 55
EleSortValue = 66
EleSortValue = 77
EleSortValue = 88
EleSortValue = 99
三、集合之间的操作
1.两个集合之间的操作，如下
//subtracting(),创建一个集合，里面的元素存在于a不存在于c
print("存在于a而不存在于c: \(a.subtracting(c).sorted())")
//intersection(),创建一个集合，里面元素为a和c共有的元素
print("a和c共有的元素: \(a.intersection(c).sorted())")
//union()，创建一个集合，里面的元素为a和c所有的元素
print("a和c元素的集合: \(a.union(c).sorted())")
//symmetricDifference(),创建一个集合，里面的元素为a和c的非共同元素
print("a和c的非共同元素: \(a.symmetricDifference(c).sorted())")
运行结果
存在于a而不存在于c: [1, 9]
a和c共有的元素: [3, 5, 7]
a和c元素的集合: [1, 2, 3, 5, 7, 9]
Program ended with exit code: 0
2.集合之间的相等与成员关系，如下
let a:Set<Int> = [1,3,5,7,9]
let b:Set<Int> = [0,2,4,6,8]
let c:Set<Int> = [9,3,7,5]
let d:Set<Int> = [11,33,55,77]
//1.判断两个集合是否相等（拥有相同的值）
print("c和d\((c == d) == true ?"相等":"不相等")")
//2.判断一个集合是否为另一个集合的子集合，（不确定两个集合是否相等）
print("c\(c.isSubset(of: d) == true ? "是":"不是")d的子集合")
print("c\(c.isSubset(of: a) == true ? "是":"不是")a的子集合")
//3.判断一个集合是否为另一个集合的父集合，（不确定两个集合是否相等）
print("a\(a.isSuperset(of: c) == true ? "是":"不是")c的父集合")
//4.判断一个集合是否是另外一个集合的父集合，且两个集合不相等
print("a\(a.isStrictSuperset(of: c) == true ? "是":"部署")c的父集合，且两个集合不相等")
//5.判断一个集合是否是另外一个集合的子集合，且两个集合不相等
print("c\(c.isStrictSubset(of: a) == true ? "是":"部署")a的子集合，且两个集合不相等")
//6.判断两个集合是否有相同的值
print("a和d\(a.isDisjoint(with: d) == true ? "包含":"不包含")相同的值")
运行结果
c和d不相等
c不是d的子集合
c是a的子集合
a是c的父集合
a是c的父集合，且两个集合不相等
c是a的子集合，且两个集合不相等
a和d包含相同的值
Program ended with exit code: 0
Dictionary
一、字典的创建，如下
var dict01 = Dictionary<Int,String>()
var dict02:[Int:String] = Dictionary.init()
var dict03:[String:String] = [:]
var dict04 = ["key":"value"] //被自动推断为Dictionary<String, String>类型
let dict = ["key":"value"]
二、字典的访问和修改
//访问和修改字典
var dictionary:[String:String] = ["key1":"value1","key2":"value2","key3":"value3"]
print("dictionary's count = \(dictionary.count)")//获取键值对数量
print("dictionary \(dictionary.isEmpty == true ?"is":" is not") empty")//判断字典是否为空
let value:String = dictionary["key3"]!//将key做下标，获取对应的value
print("\(String(describing: value))")
dictionary["key3"] = "value-value3"//将key做下标，设置对应的值
let value2:String = dictionary["key3"]!
print("\(String(describing: value2))")
dictionary.updateValue("ccc-value", forKey: "key1")//通过updateValue（）更新某个key对应的value,返回值为更新对应value的值
print(dictionary)
print("\(String(describing: dictionary.updateValue("ccc-value", forKey: "key1")))")
运行结果
dictionary's count = 3
dictionary is not empty
value3
value-value3
["key2": "value2", "key3": "value-value3", "key1": "ccc-value"]
Optional("ccc-value")
Program ended with exit code: 0
