Swift Set的基本用法

1、Set 的概念

• Set 是指具有某种特定性质的具体的或抽象的对象汇总而成的集体。其中，构成 Set 的 这些对象则称为该 Set 的元素

2、集合的三个特性

• 确定性 :给定一个集合，任给一个元素，该元素或者属于或者不属于该集合，二者必居其一
• 互斥性 : 一个集合中，任何两个元素都认为是不相同的，即每个元素只能出现一次
• 无序性 : 一个集合中，每个元素的地位都是相同的，元素之间是无序的

3、Swift 里面的集合

• Swift 的集合类型写做 Set，这里的 Element 是 Set 要储存的类型。不同于数组，集合没有等价的简写

4、创建 Set

• 使用初始化器语法来创建一个确定类型的空 Set
• 使用数组字面量创建 Set

//创建一个空的 Set 类型,必须要确定类型
var number = Set<Int>()
number.insert(2)
print(number)

//字面量创建 Set
var course: Set<String> = ["math", "English", "Chinese"]
course.insert("history")  // Set 是无序的
print(course)

5、Set 类型的哈希值

• 为了能让类型储存在 Set 当中，它必须是可哈希的——就是说类型必须提供计算它自身哈希值的方法
• 所有 Swift 的基础类型(比如 String, Int, Double, 和 Bool)默认都是可哈希的，并且可以用于 Set 或者 Dictionary 的键
• 自定义类型需要实现 Hashable 协议

struct Person {
    var name: String
    var age: Int
}
//此时声明Person类型的扩展,遵循并实现 Hashable 协议
extension Person: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
        hasher.combine(age)
    }
}
let personSet: Set<Person> = [Person(name: "张三", age: 24)]  //如果 Person 类没有遵循并实现 Hashable 协议的会报错

6、访问和修改 Set

1> 遍历 Set

• 可以使用 For - in 遍历 Set
• 因为 Set 是无序的，如果要顺序遍历 Set，使用 sorted()方法

var course: Set<String> = ["math", "English", "Chinese"]
for i in course {
    print(i)  //因为 Set 是无序的,所以此时遍历 Set 中的元素是乱的
}
print("---------")
for i in course.sorted() {
    print(i)  //此时是按顺序排列遍历出来的
}

2> 访问 Set

• 使用 count 获取 Set 里元素个数
• 使用 isEmpty 判断 Set 是否为空

let set: Set<Character> = ["a", "b", "c"]
print(set.count)
print(set.isEmpty)

3> 添加元素

• insert(_: ) 添加一个元素到 Set
• update(with:) 如果已经有相等的元素，替换为新元素。如果 Set 中没有，则插入

var set: Set<Character> = ["a", "b", "c"]
set.insert("d")
print(set)

struct Person {
    var name: String
    var age: Int
}
extension Person: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
    }
}
//在调用 update(with:) 方法时,判断 更新的 name 是否与之前的 name 一致
extension Person: Equatable {
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name
    }
}
var personSet: Set<Person> = [Person(name: "zhangsan", age: 14), Person(name: "lisi", age: 25)]
//update(with:),如果已经有相等的元素,替换成新的元素,如果set中没有,则直接插入
personSet.update(with: Person(name: "zhangsan", age: 22))
print(personSet)

4> 移除元素

• filter(_: ) 返回一个新的 Set，新 Set 的元素是原始 Set 符合条件的元素
• remove(_: ) 从 Set 当中移除一个元素，如果元素是 Set 的成员就移除它，并且返回移除的 值，如果合集没有这个成员就返回 nil
• removeAll() 移除所有元素
• removeFirst() 移除 Set 的第一个元素，因为 Set 是无序的，所以第一个元素并不是放入的 第一个元素

struct Person {
    var name: String
    var age: Int
}
extension Person: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
    }
}
//在调用 update(with:) 方法时,判断 更新的 name 是否与之前的 name 一致
extension Person: Equatable {
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name
    }
}
var personSet: Set<Person> = [Person(name: "zhangsan", age: 28), Person(name: "lisi", age: 29)]
//update(with:),如果已经有相等的元素,替换成新的元素,如果set中没有,则直接插入
personSet.update(with: Person(name: "zhangsan", age: 22))
personSet.update(with: Person(name: "wangwu", age: 16))
print(personSet.filter({ $0.age > 20 }))  //返回的是符合条件的 Person 对象
print(personSet)

var personSet: Set<Person> = [Person(name: "zhangsan", age: 28), Person(name: "lisi", age: 29)]
//update(with:),如果已经有相等的元素,替换成新的元素,如果set中没有,则直接插入
personSet.update(with: Person(name: "zhangsan", age: 22))
personSet.update(with: Person(name: "wangwu", age: 16))
personSet.remove(Person(name: "zhangsan", age: 33))
print(personSet)  //因为关联的 name 属性, 不管 age 是否相等,都会删除 name 为 "zhangsan" 的这个对象

var personSet: Set<Person> = [Person(name: "zhangsan", age: 28), Person(name: "lisi", age: 29)]
//update(with:),如果已经有相等的元素,替换成新的元素,如果set中没有,则直接插入
personSet.update(with: Person(name: "zhangsan", age: 22))
personSet.update(with: Person(name: "wangwu", age: 16))
//personSet.remove(Person(name: "zhangsan", age: 33))
personSet.removeFirst() //因为 Set 是无序的,所以删除的并不是 放入的第一个元素
print(personSet)

7、执行 Set 操作

1> 基本 Set 操作的定义

• intersection(_: ) 交集，由属于A且属于B的相同元素组成的集合，记作A∩B(或B∩A)
• union(_: ) 并集，由所有属于集合A或属于集合B的元素所组成的集合，记作A∪B(或B∪A)
• symmetricDifference(_: ) 对称差集，集合A与集合B的对称差集定义为集合A与集合B中所有不属 于A∩B的元素的集合
• subtracting(_: ) 相对补集，由属于A而不属于B的元素组成的集合，称为B关于A的相对补集，记 作A-B或A\B

2> 基本 Set 操作

let set1: Set<Character> = ["A", "B", "C"]
let set2: Set<Character> = ["B", "E", "F", "G"]
//交集
print(set1.intersection(set2))   //输出: ["B"]
//并集
print(set1.union(set2))   //输出: ["A", "F", "G", "B", "C", "E"]
//相对差集
print(set1.symmetricDifference(set2))  //输出: ["E", "C", "A", "G", "F"]
//相对补集
print(set1.subtracting(set2))    //输出: ["C", "A"]
print(set2.subtracting(set1))    //输出: ["F", "E", "G"]

3> Set 判断方法

• isSubset(of:) 判断是否是另一个 Set 或者 Sequence 的子集
• isSuperset(of:) 判断是否是另一个 Set 或者 Sequence 的超集
• isStrictSubset(of:) 和 isStrictSuperset(of:) 判断是否是另一个 Set 的子集或者超集，但是 又不等于另一个 Set
• isDisjoint(with:) 判断两个 Set 是否有公共元素，如果没有返回 true，如果有返回 false

let smallSet: Set = [1, 2, 3]
let bigSet: Set = [1, 2, 3, 4]
print(smallSet.isSubset(of: bigSet))   //输出: true
print(bigSet.isSuperset(of: smallSet))  //输出: true
print(smallSet.isStrictSubset(of: bigSet))  //输出: true  真子集
print(bigSet.isStrictSuperset(of: smallSet))  //输出: true  真超集
print(smallSet.isDisjoint(with: bigSet))  //输出: false