集合类型（Collection Types）

Swift提供了三种种集合类型来存放多个值——数组(Array)、字典(Dictionary)和集合(Set)。数组把相同类型的值存放在一个有序链表里。字典把相同类型的值存放在一个无序集合里，这些值可以通过唯一标识符（也就是键）来引用和查找。集合中存放的是值都是唯一且无序的。

在Swift里，数组和字典里所能存放的值的类型是明确的。这意味着你不能误把一个错误类型的值添加到数组或字典里，也意味着你可以明白无误地知道从数组或字典里取得的值会是什么类型的。Swift集合是类型明确的，这保证了你的代码会清楚地知道它们所能处理的值的类型，并让你能在代码开发阶段就发现任何输入错误。

Array Set Dictionary

1. 数组

1-1. 创建数组

//创建空数组
let someInts1 = [Int]()
print(someInts1)    //[]
let someInts2:Array<Int> = [];
print(someInts2)    //[]

//通过一起添加两个数组来创建数组
let someInts3 = someInts1+someInts2
print(someInts3)    //[]

//使用默认值创建数组
let someStrs3 = Array.init(repeating: "0", count: 3);
print(someStrs3)    //["0", "0", "0"]

//使用数组立即数创建数组
let shoppingList: [String] = ["Eggs", "Milk"]
print(shoppingList) //["Eggs", "Milk"]

let shoppingList1 = ["Eggs", "Milk"]
print(shoppingList1)    //["Eggs", "Milk"]

1-2. 访问和修改数组

//读取数组元素个数
var shoppingList: [String] = ["Eggs", "Milk"]
print(shoppingList.count) //2

//快速检测数组中元素个数是否为0
let shoping = shoppingList.isEmpty ? "isEmpty" : "notEmpty"
print(shoping)  //notEmpty

//增加元素
shoppingList.append("Flour")
print(shoppingList) //["Eggs", "Milk", "Flour"]

//拼接一个数组
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
 print(shoppingList)    //["Eggs", "Milk", "Flour", "Chocolate Spread", "Cheese", "Butter"]

//通过下标读取元素
let food = shoppingList[1]
print(food) // Milk

//通过下标替换元素
shoppingList[0] = "Six eggs"
print(shoppingList) //["Six eggs", "Milk", "Flour", "Chocolate Spread", "Cheese", "Butter"]

//通过下标替换指定范围的元素
shoppingList[shoppingList.count-3...shoppingList.count-1] = ["Bananas", "Apples"]
print(shoppingList) //["Six eggs", "Milk", "Flour", "Bananas", "Apples"]

//根据索引插入单个元素
shoppingList.insert("Maple Syrup", at: 0)
print(shoppingList) //["Maple Syrup", "Six eggs", "Milk", "Flour", "Bananas", "Apples"]

//根据索引插入数组
shoppingList.insert(contentsOf: ["1","2"], at: 2)
print(shoppingList) //["Maple Syrup", "Six eggs", "1", "2", "Milk", "Flour", "Bananas", "Apples"]

//删除数组中第一个元素
shoppingList.removeFirst()
print(shoppingList) //["Six eggs", "1", "2", "Milk", "Flour", "Bananas", "Apples"]

//删除数组前几个元素
shoppingList.removeFirst(1)
print(shoppingList) //["1", "2", "Milk", "Flour", "Bananas", "Apples"]

//删除数组中最后一个元素
shoppingList.removeLast()
print(shoppingList) //["1", "2", "Milk", "Flour", "Bananas"]

//删除数组中最后几个元素
shoppingList.removeLast(1)
print(shoppingList) //["1", "2", "Milk", "Flour"]

//遍历全部数组得到元素
for item in shoppingList {
    print(item)
    //1
    //2
    //Milk
    //Flour
}

//遍历全部数组得到元素和索引值
for (index, value) in shoppingList.enumerated() {
    print("Item \(index + 1): \(value)")
    //Item 1: 1
    //Item 2: 2
    //Item 3: Milk
    //Item 4: Flour
}

2. 集合

集合中存放的值必须是满足Hashable协议的。

2-1. 创建集合

//创建空集合
var letters = Set<Character>()
print(letters)  //[]

//使用数组创建集合
let letters1:Set<Character> = []
print(letters1) //[]

//集合类型不能从数组单独推断，因此Set必须显式声明类型
let letters2:Set = ["1","2","1"]
print(letters2) //["2", "1"],自动过滤掉重复的元素

2-2. 访问修改集合

var letters:Set = ["1","2","1","3","4","5","6"]
print(letters) //["2", "1", "6", "3", "4", "5"],自动过滤掉重复的元素

//计算集合元素数量
print(letters.count)    //6

//判断集合是否为空
print(letters.isEmpty)  //false

//添加元素
letters.insert("34")
print(letters)      //["2", "1", "34", "6", "3", "4", "5"]

//删除元素,如果该项目是集合的成员，则删除该项目，并返回删除的值;如果集合不包含该值，则返回nil;
if let removedGenre = letters.remove("1") {
    print("\(removedGenre)? I'm over it.")
} else {
    print("I never much cared for that.")
}//1? I'm over it.

//检查集合是否包含某项目
print(letters.contains("Funk")) //false

//遍历集合
for item in letters {
    print(item)
    //2
    //34
    //6
    //3
    //4
    //5
}

//按特定顺序遍历集合,sorted()方法按照从小到大排序
for item in letters.sorted() {
    print(item)
    //2
    //3
    //34
    //4
    //5
    //6
}

2-3. 集合操作

基本操作，如图：阴影部分为集合a和集合b的计算结果。

集合基本操作

• 使用intersection( )方法计算得到包含两个集合公有值的集合。
• 使用 symmetricDifference( )方法计算得到去除两个集合公有值，剩下所有值的集合。
• 使用union( )方法计算得到一个包含两个集合中的所有值的新集合。
• 使用subtracting( ) 方法计算得到集合的补集。

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
 
print(oddDigits.intersection(evenDigits).sorted())
// []
print(oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted())
// [1, 2, 9]
print(oddDigits.union(evenDigits).sorted())
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(oddDigits.subtracting(singleDigitPrimeNumbers).sorted())
// [1, 9]

2-4. 集合比较

如下图，集合A是集合B的超集，集合B是集合A的子集，集合A包含集合B所有的元素；集合A和集合C相交，集合A和集合C有公共的元素；集合B和集合C互异，因为集合B和集合C中没有公共的元素；

图片.png

• 使用（==）来判断两个集合是否相同。
• 使用 B.isSubset(of:A) 方法判断集合B是否是集合A的子集。
• 使用 A.isSuperset(of:B) 方法判断集合A是否是集合B的超集。
• 使用 B.isStrictSubset(of:A) 方法判断集合B是否是集合A的真子集（集合A不等于集合B）。
• 使用 A.isStrictSuperset(of:B) 方法判断集合A是否是集合B的超集，但集合A不等于集合B。
• 使用 A.isDisjoint(with:B) 方法判断集合A和集合B是否具有交集。

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

print(houseAnimals==farmAnimals)        //false
print(houseAnimals.isSubset(of: farmAnimals))   //true
print(farmAnimals.isSuperset(of: houseAnimals)) //true
print(farmAnimals.isDisjoint(with: cityAnimals))//true

3. 字典

一个字典所有的Key类型相同，所有的Value类型相同。key与Value一一对应的键值对，且是无序存储的。

3-1. 创建字典

//创建字典
let namesOfIntegers = [Int: String]()   //namesOfIntegers is an empty [Int: String] dictionary
print(namesOfIntegers)  //[:]

let namesOfIntegers1:Dictionary<Int,String> = [:]
print(namesOfIntegers1)  //[:]

//使用字典创建字典
let namesOfIntegers2:[Int:String] = [1:"1",2:"2"]
print(namesOfIntegers2)  //[2: "2", 1: "1"]

let namesOfIntegers3 = [1:"1",2:"2"]
print(namesOfIntegers3)  //[2: "2", 1: "1"]

3-2. 访问和修改字典

var namesOfIntegers = ["YYZ": "Toronto Pearson", "DUB": "Dublin","DRS":"DuRuiSheng"]

//计算字典键值对数量
print(namesOfIntegers.count)  //3

//判断字典是否为空
print(namesOfIntegers.isEmpty)  //

//根据Key读取字典中对应Value
print(namesOfIntegers["DRS"] ?? "该Key没有对应的Value")   //DuRuiSheng

//根据Key修改字典中对应Value,当字典中没有改Key时，不做任何操作
namesOfIntegers["YYZ"]  =   "YYZ"
print(namesOfIntegers)  //["DUB": "Dublin", "DRS": "DuRuiSheng", "YYZ": "YYZ"]

//增加键值对
namesOfIntegers["ZHTJ"] =   "ZHThinkJoy"
print(namesOfIntegers)  //["ZHTJ": "ZHThinkJoy", "DRS": "DuRuiSheng", "YYZ": "YYZ", "DUB": "Dublin"]

//更新对应Key的Value，字典中有Key，返回Key对应的旧值；否则返回nil；
let oldValue = namesOfIntegers.updateValue("ZhuHaiThinkJoy", forKey: "ZHTJ")
print(oldValue ?? "字典中没有该Key") //ZHThinkJoy
print(namesOfIntegers)  //["ZHTJ": "ZhuHaiThinkJoy", "DRS": "DuRuiSheng", "YYZ": "YYZ", "DUB": "Dublin"]

//设置Key对应的Value为nil来删除对应的键值对
namesOfIntegers["YYZ"] = nil;
print(namesOfIntegers)  //["ZHTJ": "ZhuHaiThinkJoy", "DRS": "DuRuiSheng", "DUB": "Dublin"]

//根据Key删除字典中的Value
if let removedValue = namesOfIntegers.removeValue(forKey: "DUB") {
    print("成功删除 \(removedValue).")
} else {
    print("T字典中没有DUB该Key")
}   //成功删除 Dublin.

//遍历字典
for (nameKey,nameValue) in namesOfIntegers {
    print("\(nameKey):\(nameValue)")
    //ZHTJ:ZhuHaiThinkJoy
    //DRS:DuRuiSheng
}

//遍历字典
for nameKey in namesOfIntegers.keys {
    print("\(nameKey):\(namesOfIntegers[nameKey])")
    //ZHTJ:Optional("ZhuHaiThinkJoy")
    //DRS:Optional("DuRuiSheng")
}

//遍历字典
for nameValue in namesOfIntegers.values {
    print("namesOfIntegers Value :\(nameValue)")
    //namesOfIntegers Value :ZhuHaiThinkJoy
    //namesOfIntegers Value :DuRuiSheng
}

//获取字典的Key数组
let nameKeys = [String](namesOfIntegers.keys).sorted()
print(nameKeys)     //["DRS", "ZHTJ"]

//获取字典的Value数组
let nameValue = [String](namesOfIntegers.values).sorted()
print(nameValue)    //["DuRuiSheng", "ZhuHaiThinkJoy"]

参考链接1
参考链接2

用来记录平时遇到的问题,不对之处还望指教。