• Dictionary

1. 字典储存无序的相互关联的，同一类型的建和同一类型的值的集合
2. 字典类型的全蝎方式 Dictionary<Key, Value> 简写方式[Key: Value], 建议使用简写方式
3. 字典的key必须是可哈希的

• 创建空字典

1. 初始器方法
2. 简写方法
3. 字面量方法

var dict1 = Dictionary<String, Int>()
var dict2 = [String: Int]()
var dict3: Dictionary<String, Int> = [:]
let dict = ["zhangsan": 18, "lisi": 19]

• count 和 isEmpty

1. 可以使用 count 只读属性来找出 Dictionary 拥有多少元素
2. 使用布尔量 isEmpty 属性检查字典是否为空

print(dict.count)
print(dict.isEmpty)

• 遍历字典

1. for-in循环
2. 可以通过访问字典的 keys 和 values 属性来取回可遍历的字典的键值的集合
3. Swift 的 Dictionary 类型是无序的， 要以特定的顺序遍历字典的建或值，使用键或值的 sorted() 方法

let dict = ["zhangsan": 18, "lisi": 19, "wangwu": 20]

for (key, value) in dict {
    print("name \(key), age \(value)")
}
for key in dict.keys.sorted() {
    print("name \(key), age \(dict[key])")
}

字典Dictionary的常见操作

• 添加或更新元素

1. 使用下标添加或更新元素

var dict = ["zhangsan": 18, "lisi": 19, "wangwu": 20]
dict["zhaoliu"] = 21
print(dict)
dict["zhangsan"] = 281
print(dict) 

2. 使用 updateValue(_:forKey:) 方法添加或更新元素，返回一个字典值类型的可选值

struct Person {
    var name: String
    var age: Int
}
extension Person: Hashable {
    func hash(into hasher: inout Hasher) {
        hasher.combine(name)
    }
}
extension Person: Equatable {
    static func == (lhs: Person, rhs: Person) -> Bool {
        return lhs.name == rhs.name
    }
}
var personDict = [Person(name: "zhangsan", age: 18): 3000, Person(name: "lisi", age: 25): 3000]
personDict.updateValue(5000, forKey: Person(name: "zhangsan", age: 23)) //key 并未改变
print(personDict)

• 移除元素

1. 使用下标脚本语法给一个键复制 nil 来从字典当中移除一个键值对
2. 使用 removeValue(forKey:) 来从字典里移除键值对，这个方法移除键值对，如果他们存在的话， 并且返回移除的值，如果值不存在则返回nil

var dict = ["zhangsan": 18, "lisi": 19, "wangwu": 20] 
print(dict)
dict["wangwu"] = nil
print(dict)
dict.removeValue(forKey: "zhangsan")
print(dict)

• 合并两个字典

1. merge(_:uniquingKeysWith:) merging

var diction = ["a": 18, "b": 19, "c": 20]
diction.merging(["a": 3, "d": 4]) { (current, _) -> Int in
    current
}
print(diction)
diction.merging(["b": 5, "f": 20]) { (_, new) -> Int in
    new
}
print(diction) //merging不会改变原来字典的值

var dict = ["a": 18, "b": 19, "c": 20]
dict.merge(["a": 3, "d": 4], uniquingKeysWith: { (current, _) in current})
print(dict)
dict.merge(["b": 5, "f": 20], uniquingKeysWith: { (_, new) in new})
print(dict)

• firstIndex

1. 虽然字典是无序的，但是每个key-value对在扩容之前的位置是稳定的，如果你需要保持顺序的key-value对可以使用 KeyValuePairs

var dict = ["a": 18, "b": 19, "c": 20]
let index = dict.firstIndex { (_, value) -> Bool in
    value == 18
}
if let i = index {
    print(dict[i])
    print("key:\(dict[i].key)  key:\(dict[i].value)")
}

let kvs: KeyValuePairs = ["a": 18, "b": 19, "c": 20]
print(kvs)