Swift学习笔记 （五）

字典

每一个值都对应这一个唯一的键（key），就像是字典内的每一个值都有一个标示符。和数组内的元素是有区别的，字典内的元素是没有特殊的序列的。当你需要根据标示符来查找批量的值时，就可以使用字典。

Swift字典是储存一个类型的具体的键值对。和OC的NSDictionary和NSMutableDictionary有一定的区别。因为它们是使用各种的对象来作为它们的键和值，而且不提供任何有关对象的具体信息。在Swift里，对于一个特定的字典，它所能储存的键和值都是确定的，无论是明确声明的类型还是隐式推断的类型。

Swift的字典写法是Dictionary<KeyType,ValueType>,KeyType是你想要储存的键，ValueType是你想要储存的值。

唯一的限制就是KeyType必须是可哈希的（hashable）就是提供一个形式让他们自身是独立识别的。Swift的所有基础类型（字符串（String）整形（Int）双精度（Double）布尔（BOOL））在默认是可哈希的，和这些类型都常常当做字典的键。

字典实量（Dictionary Literals）

直接用一个字典实量初始化一个字典。字典实量就是使用简略写法写 一个或者多个的键值对来定义一个字典。

一个键值对是一个键和值的组合。在字典实量里面，每一个键值对总是用一个冒号把键和值分割。键值对的写法就像是一个列表，使用逗号分割，并被一对中括号[]包含着：

[key 1: value1, key 2: value2, key 3: value 3]

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
println(airport)
//[DUB: Dublin, TYO: Tokyo]

airport字典被定义为一个类型为Dictionary<String, String>, 这个字典的键类型是字符串String，和它的值的类型也是String。

注意：airport字典是被定义为一个变量（var）不是常量（let）。所以可以直接添加元素。

① 读取和修改字典

可以通过属性，方法或者下标来读取和修改字典。使用只读的count属性来检查字典包含多少个元素。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
println(airport.count)
//2

可以使用下标语法给一个字典添加一个元素。使用合适的类型作为新的键，并分配给它一个合适的值：

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
airport["LHR"] = "London"
println(airport)
//[DUB: Dublin, TYO: Tokyo, LHR: London]

也可以使用下标语法去改变一个特定健所关联的值：

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
airport["TYO"] = "Tokyo Hot"
println(airport)
//[DUB: Dublin, TYO: Tokyo Hot]

使用字典的updateValue(forKey:)方法去设置或者更新一个特定键和值。如果键不存在则会设置它的值，如果键存在则会更新它的值。

updateValue(forKey:)方法返回一个和字典的值相同类型的可选值。例如：如果字典的值的类型是String，则会返回String？或者叫“可选String”，这个可选值包含一个如果值发生更新的旧值和如果值不存在的nil值。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
if var oldValue = airport.updateValue("Dublin International",forKey:"DUB"){
println("The old value for DUB was \(oldValue)")
}
//The old value for DUB was Dublin

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
if var oldValue = airport.updateValue("Dublin International",forKey:"DUB"){
println(airport)
}
//[DUB: Dublin International, TYO: Tokyo]

也可以使用下标语法通过特定的键去读取一个值。因为当它的值不存在的时候，可以返回它的键，字典的下标语法会返回一个字典的值的类型的可选值。若果字典中的键包含对应的值，字典下标语法会返回这个键所对应的值，否者返回nil。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
if let airportName = airport["DUB"]{
println("The name of airport is \(airportName)")
}else{
println("The airport is not in the airport dictionary")
}
//The name of airport is Dublin

可以使用下标语法把它的值分配为nil，来一出这个键值对：

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
airport["APL"] = "Apple International"
println(airport) //[DUB: Dublin, TYO: Tokyo, APL: Apple International]
airport["APL"] = nil
println(airport) //[DUB: Dublin, TYO: Tokyo]

也可以使用removeValueForKey方法从一个字典中移除一个键值对。这个方法如果存在键所对应的值，则移除一个键值对，并返回被移除的值，否则返回nil。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
airport["APL"] = "Apple International"
if let removeValue = airport.removeValueForKey("DUB"){
println("the remove airport's name is \(removeValue)")
}else{
println("the airport dictionary does not contain value for DUB")
}
//the remove airport's name is Dublin

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
airport["APL"] = "Apple International"
if let removeValue = airport.removeValueForKey("DAB"){
println("the remove airport's name is \(removeValue)")
}else{
println("the airport dictionary does not contain value for DAB")
}
//the airport dictionary does not contain value for DAB

遍历字典

可以使用一个for-in循环来遍历字典的键值对。字典中的每一个元素都会返回一个元组（tuple）。可以分解这个元组，并用临时变量或者常量来储存它。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
for (airportCode, airportName) in airport{
println("\(airportCode):\(airportName)")
}
//DUB:Dublin
//TYO:Tokyo

也可以读取字典的keys属性或者values属性来遍历这个字典的键或值的集合。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
for airportCode in airport.keys{
println("Airport code:\(airportCode)")
}
for airportName in airport.values{
println("Airport name:\(airportName)")
}
//Airport code:DUB
//Airport code:TYO
//Airport name:Dublin
//Airport name:Tokyo

当需要一个接口来创建一个字典的键 或者 值的数组实例，可以使用keys 或者 values 属性来初始化一个数值。

var airport: Dictionary<String, String> = ["TYO" : "Tokyo", "DUB" : "Dublin"]
let airportCodes = Array(airport.keys)
println(airportCodes) //[DUB, TYO]
let airportNames = Array(airport.values)
println(airportNames) //[Dublin, Tokyo]

注意：Swift中的字典类型是非序列化集合。

创建一个空字典

可以使用确定类型的语法创建一个空的字典

var namesOfIntegers = Dictionary<Int,String>()
println(namesOfIntegers)  //[:]

如果上下文（context）中已经提供类型信息，可用椅子字典实量创建一个空的字典，写作[:]（中括号对，冒号）

var namesOfIntegers = Dictionary<Int,String>()
namesOfIntegers[16] = "sixteen"
println(namesOfIntegers) //[16: sixteen]
namesOfIntegers = [:]
println(namesOfIntegers) //[:]

可变集合类型

数组和字典都是一个集合中一起储存不同的变量。如果创建一个数组或者字典，再包含一个变量，创建的这个变量被成为可变的（mutable），这代表，你可以在创建之后增加更多的元素来改变这个集合的长度，或者移除已经包含的。相反的，如果你把一个数组或者字典定义为常量，则这个数组或者字典不是可变的，它们的长度并不能被改变。

在字典中，不可变也意味着你不能替换已经存在的键的值。一个不可变字典，一旦被设置就不能改变。

数组的不可变有一点点的不同。仍然不能做任何有可能修改不可变数组的行为，但是可以重新设置一个已经存在的索引，使当Swift的数组的长度确定时，能更好的优化数组的性能。