Swift--原生集合类型

• 数组

• 字典

• Set集合

数组

数组：是一串有序的由相同类型元素构成的集合。数组中的集合元素是有序的，可以重复出现。数组更关心元素是否有序，而不关心是否重复。

var studentList1: Array<String> = ["张三","李四", "王五", "董六"]  //可变数组
//也可以写成下面这样 (Swift编译器会根据赋值的初始值，自动推断出来数组是字符串的数组类型)
//var studentList1 = ["张三","李四", "王五", "董六"]

var studentList2: [String] = ["张三","李四", "王五", "董六"] //可变数组

let studentList3: Array<String> = ["张三","李四", "王五", "董六"]   //不可变数组

var studentList4 = [String]() //数组是一个结构体，结构体具有构造函数。

可变数组

var声明的数组是可变数组，如果初始化之后不再修改数组，应该将数组声明为let的，即不变的数组。
对可变数组中的元素进行追加、插入、删除和替换等修改操作。
追加元素可以使用数组append(:)方法、+和+=操作符实现， +和+=操作符能将两个数组合并一起。插入元素可以使用数组的insert(:at)方法实现， 删除元素可以使用数组的remove(at:)方法实现。

////可变数组
var studentList: [String] = ["张三","李四", "王五"]
print(studentList) //输出结果：["张三", "李四", "王五"]


//使用append追加元素
studentList.append("董六")
print(studentList) //输出结果：["张三", "李四", "王五", "董六"]

//使用+=对两个数组进行连接
studentList += ["刘备", "关羽"]
print(studentList)//输出结果：["张三", "李四", "王五", "董六", "刘备", "关羽"]

//使用insert插入元素
studentList.insert("诸葛亮", at: 1)
print(studentList)//输出结果：["张三", "诸葛亮", "李四", "王五", "董六", "刘备", "关羽"]

//使用remove删除元素
 let removeStudent = studentList.remove(at: 0) //remove之后是有返回值的
print(studentList)//输出结果：["诸葛亮", "李四", "王五", "董六", "刘备", "关羽"]
print(removeStudent)//输出结果：张三

//替换
studentList[0] = "张飞"
print(studentList)//输出结果：["张飞", "李四", "王五", "董六", "刘备", "关羽"]

数组遍历

数组最常用的操作是遍历，就是将数组中的每一个元素取出来，进行操作或计算。整个遍历过程与循环分不开，我们可以使用for-in循环进行遍历。

////数组遍历

for item in studentList {
    print(item)
}

//enumerated 方法可以获得一个元组类型（索引，元素)
for (index, value) in studentList.enumerated(){
    print("index=\(index): value=\(value)")
}

输出结果如下：

image.png

字典

字典的声明与初始化

字典是由两部分集合构成的，一个是键（key）集合，一个是值（value）集合。键集合是不能有重复元素的，而值集合可以，键和值是成对出现的。

字典声明和初始化

声明一个Dictionary类型的时候可以使用下面语句之一：
var studentDictionary1: Dictionary<Int, String>
var studentDictionary2: [Int: String]

var studentDictionary1: Dictionary<Int, String> = [102 : "张三", 103: "李四", 104: "王五"]

var studentDictionary2: [Int : String] = [102 : "张三", 103: "李四", 104: "王五"]

//省略类型，直接赋值
var studentDictionary3 = [102 : "张三", 103: "李四", 104: "王五"]

//实例化空的字典, 方法一
var studentDictionary4 = Dictionary<Int, String>()

//实例化空的字典, 方法二
var studentDictionary5 = [Int : String]()

可变字典

• var 声明的字典是可变字典，如果初始化之后不再修改字典，应该将字典声明为let的，即不变的字典。
• 1、字典元素追加，只要给一个不存在的键赋一个有效值，就会追加一个“键值”对元素。
• 2、字典元素删除有两种方法：一种是给一个键赋值为nil, 这样就可以删除元素；一种是通过字典的removeValue(forKey:)方法删除元素。
• 3、字典元素替换两种方法:一种是直接给一个存在的键赋值，这样值就会替换旧值；另一种方法是通过updateValue(_:forKey:)方法替换，方法的返回值是要替换的值。

////可变字典
var studentDictionary = [102 : "张三", 105: "李四", 109: "王五"]

//追加
studentDictionary[110] = "董六"
print(studentDictionary)//输出：[105: "李四", 110: "董六", 109: "王五", 102: "张三"]
print(studentDictionary.count)//输出：4

//删除1
studentDictionary[105] = nil
print(studentDictionary) //输出：[110: "董六", 109: "王五", 102: "张三"]

//删除2
let delStudent = studentDictionary.removeValue(forKey: 102)
print(studentDictionary) //输出：[110: "董六", 109: "王五"]
print(delStudent!)  //输出：张三

//替换1
studentDictionary[109] = "小七"
print(studentDictionary) //输出：[110: "董六", 109: "小七"]

//替换2
let updateStudent = studentDictionary.updateValue("小八", forKey: 110)
print(studentDictionary) //输出：[110: "小八", 109: "小七"]
print(updateStudent!)    //输出：董六

注意：如果不需要关心删除或替换的返回值的情况下，优先考虑 删除1 的方法和替换1的方法，简单方便。

字典遍历

字典遍历集合也是字典的重要操作。与数组不同，字典有两个集合，因此遍历过程可以只遍历值得集合，也可以只遍历键的集合，也可以同时遍历。这些遍历过程都是通过for-in循环实现的。

//遍历键集合 ---  keys获得键集合
for studentID in studentDictionary.keys {
    print("学号：\(studentID)")
}

//遍历值集合 --- values获得值集合
for studentName in studentDictionary.values {
    print("学生：\(studentName)")
}

//遍历键值对集合 --- (studentId, studentName)元组类型

for (studentId, studentName) in studentDictionary {
    print("学号：\(studentId) 学生：\(studentName)")
}

Set

Swift中Set集合是由一串无序的，不能重复的 相同类型元素构成的集合。

注：如果与数组比较，数组中的元素是有序的，可以重复出现，而Set中是无序的，不能重复的元素。数组强调的是有序，Set强调的是不重复。当不考虑顺序，而且没有重复的元素时，Set和数组可以互相替换。

Set声明和初始化

在声明一个Set类型时可以使用下面的语句
var studentList: Set<String>
声明Set类型时没有像数组那样的简化写法，如数组字符串[String]。

//Set的声明和初始化
let studentList5: Set<String> = ["张三", "李四", "王五", "董六"]
var studentList6 = Set<String>() //构造函数

let studentList7 = ["张三", "李四", "王五", "董六"]  //系统自动推导出来是数组集合的，而不是Set集合的
let studentList8:[String] = ["董六", "张三", "李四", "王五"]

let studentList9: Set<String> = ["董六", "张三", "李四", "王五"]

print(studentList7 == studentList8)//输出：false,（studentList7和studentList8都是数组集合，但元素顺序不同）

print(studentList5 == studentList9)//输出：true，（studentList5和studentList9都是Set集合，元素内容相同，无重复内容，与顺序无关）

注： 如果两个集合元素内容一样，元素顺序不同，那么它们也是相等的。 即：Set集合["张三", "李四", "王五", "董六"] 等于 Set集合 ["董六", "张三", "李四", "王五"]

可变Set集合

• var声明的Set集合是可变的，如果初始化之后不再修改，应该将Set集合声明为let的，即不变的Set集合。
• 我们可以对可变Set集合的元素进行插入和删除等修改操作。
• 1、插入元素：可以使用集合的insert(_:)方法实现。
• 2、删除元素：可以使用集合的removeFirst()和remove(_:)方法实现。

////可变Set集合
var studentList10: Set<String> = ["张三", "李四", "王五", "董六"]
print(studentList10) //输出：["董六", "李四", "张三", "王五"]

//删除 removeFirst的删除具有随机性
let removeStudent2 = studentList10.removeFirst()
print(removeStudent2)  //输出：王五
print(studentList10)   //输出：["李四", "董六", "张三"]

//删除
studentList10.remove("张三")
print(studentList10)  //输出：["李四", "董六"]

//插入
studentList10.insert("张三")
print(studentList10) //输出：["李四", "董六", "张三"]

//使用contains来判断是否包含某个元素
if studentList10.contains("张三") {
    print("OK")     //输出：OK
}

Set集合遍历

Set集合最常用的操作是遍历，就是将数组中的每一个元素取出来，以便进行操作或计算。整个遍历过程与循环分不开，我们可以使用for-in 进行循环遍历。

////Set遍历

var studentList11: Set<String> = ["张三", "李四", "王五", "董六"]

for item in studentList11 {
    print(item)
}

for (index, value) in studentList11.enumerated() {
    print("index = \(index) : value = \(value)")
}

输出结果如下：

image.png