swift-集合

Swift提供了三种主要的集合类型，称为数组、集合和字典，用于存储值的集合。 数组是有序的值集合。 集合是唯一值的无序集合。 字典是键值关联的无序集合。Swift 的数组、集合和字典类型被实现为泛型集合。如果创建数组、集合或字典，并将其分配给变量，则创建的集合将是可变的。 这意味着您可以在集合创建后通过添加、删除或更改集合中的项目来更改（或变异）集合。 如果将数组、集合或字典分配给常量，则该集合是不可变的，并且其大小和内容无法更改。

在不需要更改集合的所有情况下创建不可变集合是一种很好的做法。 这样做可以让您更轻松地对代码进行推理，并使 Swift 编译器能够优化您创建的集合的性能。

数组

存储相同类型的值的集合，有序可重复。Swift的Array类型桥接到Object-C的NSArray类。
数组创建全写为Array<类型a>，用于存储类型a相关的元素的集合，我们也可以简写成 [类型a]。

1. 构建数组

/// 构建一个空数组
var emptyArray:[Int] = []
/// 数组添加元素
emptyArray.append(3)
/// 数组重新置为空
emptyArray = []
/// 创建有默认值的数组
var oneArray = Array(repeating: 0.0, count: 3)
var twoArray = Array(repeating: 2.5, count: 3)
/// 两个数组相加
print(oneArray+twoArray) // [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
/// 使用字面量创建数组
var threeArray:[String] = ["字","面","量"]
/// 可以简写
var threeArray1 = ["字","面","量"]
复制代码

2. 修改和访问数组

// 答应数组有多少个元素
print("数组threeArray1有\(threeArray1.count)个元素") //数组threeArray1有3个元素
/// 数组判空
threeArray1.isEmpty //false
/// 添加元素
threeArray1.append(".")
// 使用加法赋值运算符 (+=) 附加一个或多个兼容项的数组
threeArray1 += threeArray
print(threeArray1) // ["字", "面", "量", ".", "字", "面", "量"]
/// 使用下标来获取对应的数据
print(threeArray1[0]) // 字
/// 根据下标来设置数组元素的值
threeArray1[0] = "一"
print(threeArray1) // ["一", "面", "量", ".", "字", "面", "量"]
/// 替换一段范围内的值
threeArray1[0...3] = ["2"]
print(threeArray1) // ["2", "字", "面", "量"]
/// 在下标前插入元素
threeArray1.insert("AAA", at: 0)
print(threeArray1) //["AAA", "2", "字", "面", "量"]
/// 删除对应下标元素
threeArray1.remove(at: 0)
print(threeArray1) //["2", "字", "面", "量"]
/// 删除第一个元素
threeArray1.removeFirst()
print(threeArray1) //["字", "面", "量"]
/// 删除最后一个
threeArray1.removeLast()
print(threeArray1) //["字", "面"]
/// 遍历数组
for item in threeArray1 {
    print(item)
    // 字
    // 面
}
/*
 如果您需要每个项目的整数索引及其值，请改用 enumerated() 方法迭代数组。 对于数组中的每个项目，enumerated() 方法返回一个由整数和项目组成的元组。
 **/
for (index,ietm) in threeArray1.enumerated() {
    print("threeArray1第\(index)个元素是\(ietm)")
//    threeArray1第0个元素是字
//    threeArray1第1个元素是面
}
复制代码

集合

集合是无序且元素不能重复，当元素顺序不重要切元素值要保证唯一的时候可以使用集合。

集合类型的哈希值

一个类型必须是可散列的，才能存储在一个集合中——也就是说，该类型必须提供一种为自己计算散列值的方法。 散列值是一个Int值，对于相等比较的所有对象都相同，因此如果 a == b，则 a 的散列值等于 b 的散列值。

语法

Swift 集合的类型写为 Set< Element >，其中 Element 是集合允许存储的类型。 与数组不同，集合没有等效的简写形式。

var set:Set = Set<Element: Hashable>()
复制代码

初始化集合

使用特定类型来创建空集合

var set:Set = Set<Int>()
set.insert(1)
复制代码

字面量创建集合

您还可以使用数组字面量初始化一个集合，作为将一个或多个值写入集合集合的一种速记方式。

var set: Set<String> = ["字", "面", "量"]
复制代码

不能仅从数组字面量推断集合类型，因此必须显式声明类型 Set。 但是，由于 Swift 的类型推断，如果您使用仅包含一种类型值的数组字面量对其进行初始化，则不必编写集合元素的类型。

var set:Set = ["字", "面", "量"]
复制代码

使用集合

集合常用的方法

var set:Set = ["字", "面", "量"]
/// 获取集合项目数
print("set num \(set.count)") //set num 3
/// 判断集合是否为空
if !set.isEmpty {
    print("集合不为空")
}
/// 集合插入元素
set.insert(".")
print(set) // ["面", ".", "字", "量"]
/// 删除某个元素
set.remove(".")
print(set) // ["字", "量", "面"]
/// 删除全部元素
set.removeAll()
print(set) // []
// 判断是否包含
set.contains("22") // false
复制代码

遍历集合

var numberSet:Set = ["1","22","333"]
/// 遍历集合
for num in numberSet {
    print(num)
    //1
    //333
    //22
}
///按照特定顺序遍历
for num in numberSet.sorted() {
    print(num)
    // 1
    // 22
    // 333
}
复制代码

集合操作

我们可以将两个集合合并，确定有哪些共同的值。或者判断集合A是否全部包含集合B或者部分包含，或者没有相同元素。

1.基本集合操作

获取集合A和集合B的相同的值intersection(_:)

var A:Set = [1,2,3,4,5]
var B:Set = [5,6,7,8,9]
print(A.intersection(B)) //[5]
复制代码

获取两个集合不相同的值symmetricDifference(_:)

var A:Set = [1,2,3,4,5]
var B:Set = [5,6,7,8,9]
print(A.symmetricDifference(B)) //[1, 4, 3, 9, 8, 7, 6, 2]
复制代码

使用 union(_:) 方法创建一个包含两个集合中所有值的新集合。

var A:Set = [1,2,3,4,5]
var B:Set = [5,6,7,8,9]
print(A.union(B)) //[4, 9, 7, 3, 6, 8, 1, 5, 2]
复制代码

获取不包含指定集合的集合subtracting(_:)

var A:Set = [1,2,3,4,5]
var B:Set = [5,6,7,8,9]
print(A.subtracting(B)) //[1, 2, 3, 4]
复制代码

2.集合之间的包含关系

判断集合是否相等

let houseAnimals: Set = ["?", "?"]
let farmAnimals: Set = ["?", "?", "?", "?", "?"]
let cityAnimals: Set = ["?", "?"]
if houseAnimals == farmAnimals {
    print("包含所有相同的值")
} else {
    print("不包含所有相同的值")
} // 不包含所有相同的值
复制代码

使用 isSubset(of:) 方法来确定一个集合的所有值是否都包含在指定的集合中。

let houseAnimals: Set = ["?", "?"]
let farmAnimals: Set = ["?", "?", "?", "?", "?"]
let cityAnimals: Set = ["?", "?"]
houseAnimals.isSubset(of: farmAnimals) // true
复制代码

判断是否包含指定集合全部元素isSuperset(of:)

let houseAnimals: Set = ["?", "?"]
let farmAnimals: Set = ["?", "?", "?", "?", "?"]
let cityAnimals: Set = ["?", "?"]
farmAnimals.isSuperset(of: houseAnimals) // true
复制代码

判断是否是子集或者超集

let houseAnimals: Set = ["?", "?"]
let farmAnimals: Set = ["?", "?", "?", "?", "?"]
let cityAnimals: Set = ["?", "?"]
farmAnimals.isStrictSuperset(of: houseAnimals) // true  farmAnimals是 houseAnimals的超集
houseAnimals.isStrictSubset(of: farmAnimals) // true houseAnimals 是farmAnimals的子集
cityAnimals.isStrictSubset(of: farmAnimals) // false cityAnimals 不是是farmAnimals的子集
复制代码

判断是否没有共同的值

let houseAnimals: Set = ["?", "?"]
let farmAnimals: Set = ["?", "?", "?", "?", "?"]
let cityAnimals: Set = ["?", "?"]
houseAnimals.isDisjoint(with: farmAnimals) // false
houseAnimals.isDisjoint(with: cityAnimals) // true
复制代码

字典

字典在集合中存储相同类型的键和相同类型的值之间的关联，没有定义的顺序。 每个值都与一个唯一键相关联，该键充当字典中该值的标识符。

语法

Swift 字典的类型全写为 Dictionary<Key, Value>，其中 Key 是可以用作字典键的值类型，Value 是字典为这些键存储的值类型。

var dic:Dictionary = Dictionary<Key: Hashable, Any>()
复制代码

初始化字典

var dic:Dictionary = Dictionary<String, Any>()
复制代码