第五章.集合类型

 

Swift提供了两种集合类型，分别是数组和字典（就是键值对）。

数组

数组使用有序列表存储相同类型的多重数据。简单说就是可以存储重复的值。

数组构造语句

我们可以使用字面语句来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面语句是一系列由逗号分割并由方括号包含的数值。 [value 1, value 2, value 3]。

 

下面这个例子创建了一个叫做shoppingList并且存储字符串的数组：

var shoppingList: ［String］ = ["Eggs", "Milk"] 

shoppingList变量被声明为“字符串值类型的数组“，记作String[]。 因为这个数组被规定只有String一种数据结构，所以只有String类型可以在其中被存取。 在这里，shoppinglist数组由两个String值（"Eggs" 和"Milk"）构造，并且由字面语句定义。

 

由 于Swift 的类型推断机制，当我们用字面语句构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 shoppinglist的构造也可以这样写：

var shoppingList = ["Eggs", "Milk"] 

访问和修改数组

我们可以通过数组的方法和属性来访问和修改数组，或者下标语法。 还可以使用数组的只读属性count来获取数组中的数据项数量。

println("The shopping list contains \(shoppingList.count) items.") 

使用isEmpty来作为检查count属性的值是否为0

if shoppingList.isEmpty { 
    println("The shopping list is empty.") 
} else { 
    println("The shopping list is not empty.") 
} 

也可以使用append方法在数组后面添加新的数据项：

shoppingList.append("Flour")

我们也可以使用加法赋值运算符（+=）直接添加拥有相同类型数据的数组。

shoppingList += ["Chocolate Spread", "Cheese", "Butter"] 

可以直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中：

var firstItem = shoppingList[0] 

注意:第一项在数组中的索引值是0。 Swift 中的数组索引总是从零开始。

 

可以用下标来改变某个已有索引值对应的数据值：

shoppingList[0] = "Six eggs"

 

利用区间运算符来改变一系列的数据值

shoppingList[4...6] = ["Bananas", "Apples"] 

在上面这个例子中，将数组中索引为4、5、6的值替换为"Bananas", "Apples"，需要注意的是，由于替换的值只有两个，所以索引为6的值将会从数组中移除。

 

注意： 我们不能使用下标语法在数组尾部添加新项。如果我们试着用这种方法对索引越界的数据进行检索或者设置新值的操作，我们会引发一个运行期错误。我们可以使用索引值和数组的count属性进行比较来在使用某个索引之前先检验是否有效。除了当count等于0时（说明这是个空数组），最大索引值一直是count - 1，因为数组都是从零开始。

 

在数组中插入数据

调用数组的insert(atIndex:)方法来在某个具体索引值之前添加数据项：

shoppingList.insert("Maple Syrup", atIndex: 0) 

这次insert函数调用把值为"Maple Syrup"的新数据项插入shopping列表的最开始位置，并且使用0作为索引值。

 

从数组中移除数据

使用removeAtIndex方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）:

let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引值为0的数据项被移除 
// shoppingList 现在只有6项，而且不包括Maple Syrup 
// mapleSyrup常量的值等于被移除数据项的值 "Maple Syrup"

 

数据项被移除后数组中的空出项会被自动填补，所以现在索引值为0的数据项的值再次等于"Six eggs":

firstItem = shoppingList[0] 
// firstItem 现在等于 "Six eggs" 

 

如果我们只想把数组中的最后一项移除，可以使用removeLast方法：

let apples = shoppingList.removeLast() 
// 数组的最后一项被移除了 
// shoppingList现在只有5项，不包括cheese 
//  apples 常量的值现在等于"Apples" 字符串 

 

数组的遍历

使用for-in循环来遍历所有数组中的数据项：

for item in shoppingList { 
  println(item) 
} 
// Six eggs 
// Milk 
// Flour 
// Baking Powder 
// Bananas 

 

如果我们同时需要每个数据项的值和索引值，可以使用全局enumerate函数来进行数组遍历。enumerate返回一个由每一个数据项索引值和数据值组成的键值对组。我们可以把这个键值对组分解成临时常量或者变量来进行遍历：

for (index, value) in enumerate(shoppingList) { 
    println("Item \(index + 1): \(value)")
}
// Item 1: Six eggs 
// Item 2: Milk 
// Item 3: Flour 
// Item 4: Baking Powder

 

创建并且构造一个数组

我们可以使用构造语法来创建一个由特定数据类型构成的空数组：

var someInts = [Int]() 
println("someInts is of type Int[] with \(someInts。count) items。") 
// 打印 "someInts is of type Int[] with 0 items。"（someInts是0数据项的Int[]数组） 

注意:someInts被设置为一个[Int]构造函数的输出所以它的变量类型被定义为[Int]。

 

除此之外，如果代码上下文中提供了类型信息， 例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：[]（一对空方括号）：

someInts.append(3) 
// someInts 现在包含一个INT值 
someInts = [] 
// someInts 现在是空数组，但是仍然是Int[]类型的。

 

Swift 中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（count）和适当类型的初始值（repeatedValue）传入数组构造函数：

var threeDoubles = [Double](count: 3, repeatedValue:0.0) 
// threeDoubles 是一种 [Double]数组, 等于 [0.0, 0.0, 0.0] 

 

因为类型推断的存在，我们使用这种构造方法的时候不需要特别指定数组中存储的数据类型，因为类型可以从默认值推断出来：

var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5) 
// anotherThreeDoubles is inferred as [Double], and equals [2.5, 2.5, 2.5] 

 

最后，我们可以使用加法操作符（+）来组合两种已存在的相同类型数组。新数组的数据类型会被从两个数组的数据类型中推断出来：

var sixDoubles = threeDoubles + anotherThreeDoubles 
// sixDoubles 被推断为 [Double], 等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5] 

 

字典

 

Swift 的字典使用Dictionary<keytype, valuetype">定义

字典是一种存储相同类型多重数据的存储器。每个值（value）都关联独特的键（key），键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

KeyType的唯一限制就是可哈希的，这样可以保证它是独一无二的，所有的 Swift 基本类型（例如String，Int， Double和Bool）都是默认可哈希的，并且所有这些类型都可以在字典中当做键使用。未关联值的枚举成员（参见枚举）也是默认可哈希的。

 

字典字面语句

我们可以使用字典字面语句来构造字典，他们和我们刚才介绍过的数组字面语句拥有相似语法。一个字典字面语句是一个定义拥有一个或者多个键值对的字典集合的简单语句。

 

一个键值对是一个key和一个value的结合体。在字典字面语句中，每一个键值对的键和值都由冒号分割。这些键值对构成一个列表，其中这些键值对由方括号包含并且由逗号分割：

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

 

下面的例子创建了一个存储国际机场名称的字典。在这个字典中键是三个字母的国际航空运输相关代码，值是机场名称：

var airports: Dictionary<string, string> = ["TYO": "Tokyo", "DUB": "Dublin"] 

 

airports字典被定义为一种Dictionary<string, string>,它意味着这个字典的键和值都是String类型。

 

注意： airports字典被声明为变量（用var关键字）而不是常量（let关键字）因为后来更多的机场信息会被添加到这个示例字典中。

 

和数组一样，如果我们使用字面语句构造字典就不用把类型定义清楚。airports的也可以用这种方法简短定义：

var airports = ["TYO": "Tokyo", "DUB": "Dublin"] 

因为这个语句中所有的键和值都分别是相同的数据类型，Swift 可以推断出Dictionary<string, string>是airports字典的正确类型。

 

读取和修改字典

我们可以通过字典的方法和属性来读取和修改字典，或者使用下标语法。和数组一样，我们可以通过字典的只读属性count来获取某个字典的数据项数量：

println("The dictionary of airports contains \(airports.count) items.") 
// 打印 "The dictionary of airports contains 2 items."（这个字典有两个数据项） 

 

我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个合适类型的key作为下标索引，并且分配新的合适类型的值：

airports["LHR"] = "London" 
// airports 字典现在有三个数据项 

 

我们也可以使用下标语法来改变特定键对应的值：

airports["LHR"] = "London Heathrow" 
// "LHR"对应的值 被改为 "London Heathrow 

 

作为另一种下标方法，字典的updateValue(forKey:)方法可以设置或者更新特定键对应的值。就像上面所示的示例，updateValue(forKey:)方法在这个键不存在对应值的时候设置值或者在存在时更新已存在的值。和上面的下标方法不一样，这个方法返回更新值之前的原值。这样方便我们检查更新是否成功。

 

updateValue(forKey:)函数会返回包含一个字典值类型的可选值。举例来说：对于存储String值的字典，这个函数会返回一个String?或者“可选 String”类型的值。如果值存在，则这个可选值值等于被替换的值，否则将会是nil。

if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") { 
    println("The old value for DUB was \(oldValue).") 
} 
// 打印出 "The old value for DUB was Dublin."（dub原值是dublin）

 

我们也可以使用下标语法来在字典中检索特定键对应的值。由于使用一个没有值的键这种情况是有可能发生的，可选 类型返回这个键存在的相关值，否则就返回nil：

if let airportName = airports["DUB"] { 
    println("The name of the airport is \(airportName).") 
} else { 
    println("That airport is not in the airports dictionary.") 
} 
// 打印 "The name of the airport is Dublin INTernation."（机场的名字是都柏林国际） 

 

我们还可以使用下标语法来通过给某个键的对应值赋值为nil来从字典里移除一个键值对：

airports["APL"] = "Apple Internation" 
// "Apple Internation"不是真的 APL机场, 删除它 
airports["APL"] = nil 
// APL现在被移除了 

 

另外，removeValueForKey方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值对并且返回被移除的value或者在没有值的情况下返回nil：

if let removedValue = airports.removeValueForKey("DUB") { 
    println("The removed airport's name is \(removedValue).") 
} else { 
    println("The airports dictionary does not contain a value for DUB.") 
} 
// 打印 "The removed airport's name is Dublin International."（被移除的机场名字是都柏林国际）

 

字典遍历

我们可以使用for-in循环来遍历某个字典中的键值对。每一个字典中的数据项都由(key, value)元组形式返回，并且我们可以使用暂时性常量或者变量来分解这些元组：

for (airportCode, airportName) in airports { 
    println("\(airportCode): \(airportName)") 
} 
// TYO: Tokyo 
// LHR: London Heathrow 

 

也可以通过访问他的keys或者values属性（都是可遍历集合）检索一个字典的键或者值：

for airportCode in airports.keys { 
    prINTln("Airport code: \(airportCode)") 
} 
// Airport code: TYO 
// Airport code: LHR 
 
for airportName in airports.values { 
    println("Airport name: \(airportName)") 
} 
// Airport name: Tokyo 
// Airport name: London Heathrow 

 

如果我们只是需要使用某个字典的键集合或者值集合来作为某个接受Array实例 API 的参数，可以直接使用keys或者values属性直接构造一个新数组：

let airportCodes = Array(airports.keys) 
// airportCodes is ["TYO", "LHR"] 
 
let airportNames = Array(airports.values) 
// airportNames is ["Tokyo", "London Heathrow"] 

 

注意： Swift 的字典类型是无序集合类型。其中字典键，值，键值对在遍历的时候会重新排列，而且其中顺序是不固定的。

 

创建一个空字典

我们可以像数组一样使用构造语法创建一个空字典：

var namesOfIntegers = Dictionary<int, string>() 
// namesOfIntegers 是一个空的 Dictionary<int, string> 

 

这个例子创建了一个Int, String类型的空字典来储存英语对整数的命名。他的键是Int型，值是String型。

 

如果上下文已经提供了信息类型，我们可以使用空字典字面语句来创建一个空字典，记作[:]（中括号中放一个冒号）：

namesOfIntegers[16] = "sixteen" 
// namesOfIntegers 现在包含一个键值对 
namesOfIntegers = [:] 
// namesOfIntegers 又成为了一个 Int, String类型的空字典 

 

注意： 在底层，Swift 的数组和字典都是由泛型集合来实现的，想了解更多泛型和集合信息请参见泛型。

 

注意： 在我们不需要改变数组大小的时候创建不可变数组。这样 Swift 编译器就可以优化我们创建的集合。

 

 

来源:http://www.cocoachina.com/ios/20140611/8768.html

 

2015-03-19

17:35:25