6.Swift教程翻译系列——Swift集合类型

标签：ios   swift   数组   字典   集合   

英文版PDF下载地址http://download.csdn.net/detail/tsingheng/7480427

Swift提供数组和字典两种集合类型，用来存储许多值的情况。数组有序的存储一组相同类型的值。字典也存储一组相同类型的值但是是无序的，字典中存储的值可以通过一个唯一的标识（也就是Key）来查找。

在Swift中，数组和字典总是清楚自己能存储的值的类型和key的类型。也就是说你不会错误的把其他不对应的类型存进数组或者字典。所以你也能确定从数组或者字典中取出来的值的类型肯定也不会错了。Swift使用显式类型集合来保证你的代码总是能清除的知道数组和字典中存储的值的类型，确保你在开发阶段就能发现所有类型错误。

NOTE 当你将数组赋值给其他变量或者常量，或者传递给函数或方法的时候，数组的行为跟其他类型是不太一样的，更多信息在可变集合与集合类型赋值与拷贝里面介绍。

1.数组

数组可以以有序状态存储同一类型的多个值。同一个值也可以在同一个数组的不同位置多次出现。

Swift数组能存储的值的类型是特定的。他跟OC的NSArray或者NSMutableArray类不一样，这两个类可以存储任何对象，不用说明他们返回的值是什么类型。但是在Swift里，特定的数组能存储的值的类型必须要说明清楚，要么是通过类型标注，要么通过类型推断，而且不需要一定是class类型。如果你创建一个Int值的数组，你就不能向这个数组里面存储除了Int类型意外的任何值。Swift数组总是类型安全的，总是清除数组可以存储什么类型。

数组类型简写

Swift数组的类型完整形式是Array<SomeType>这样的，SomeType就是数组允许存储的类型。你也可以使用简写形式SomeType[]。虽然说两种形式功能是相同的，但是更推荐使用简写形式，这本手册也将采取简写形式。

数组字面值

你可以使用数组字面值来初始化数组，这是将一个或多个值定义成数组的简写方式。数组字面值形式是一组值以逗号分隔，外面再加上中括号。比如[value 1, value 2, value 3]。

下面例子创建了一个数组shoppingList来存数字符串

var shoppingList: String[] = ["Eggs", "Milk"]
// shoppingList has been initialized with two initial items

NOTE 注意上面数组shoppingList是被声明为变量而不是常量，因为后面例子中还要向这个数组中添加更多地元素。

在这个例子中数组字面值只包含了两个字符串，正好匹配shoppingList的声明（只能存储字符串类型的数组），所以使用字面值赋值被允许用来初始化数组shoppingList。

因为Swift有类型推断机制，所以当你使用只包含一种类型的数组字面值来初始化数组的时候是可以不用指明数组类型的。上面shoppingList的声明可以这条语句代替 var shoppingList = ["Eggs", "Milk"] 因为用来初始化的数组字面值包含的类型都是相同的，所以Swift可以推断出Sring[]就是用来声明shoppingList的正确类型。

获取和修改数组

你可以通过数组的方法或者属性或者使用下标语法来获取和修改数组。

要想知道数组拥有几个元素，可以通过数组的只读属性count

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

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

shoppingList.append("Flour")
// shoppingList now contains 3 items, and someone is making pancakes

shoppingList += "Baking Powder"
// shoppingList now contains 4 items

shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList now contains 7 items

var firstItem = shoppingList[0]
// firstItem is equal to "Eggs”

你可以使用下标语法来修改已经存在数组中的值：

shoppingList[0] = "Six eggs"
// the first item in the list is now equal to "Six eggs" rather than "Eggs”

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList now contains 6 items

如果要再数组特定位置插入元素，需要调用数组的方法insert(atIndex:)：

shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList now contains 7 items
// "Maple Syrup" is now the first item in the list”

类似的，你可以使用removeAtIndex方法来移除数组中的元素。这个方法移除指定的元素，并且返回被移除的元素（虽然你可以忽略这个返回的元素，但是他还是会返回）：

let mapleSyrup = shoppingList.removeAtIndex(0)
// the item that was at index 0 has just been removed
// shoppingList now contains 6 items, and no Maple Syrup
// the mapleSyrup constant is now equal to the removed "Maple Syrup" string”

firstItem = shoppingList[0]
// firstItem is now equal to "Six eggs”

let apples = shoppingList.removeLast()
// the last item in the array has just been removed
// shoppingList now contains 5 items, and no cheese
// the apples constant is now equal to the removed "Apples" string”

你可以是用for-in循环来遍历数组中的元素

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

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
// Item 5: Bananas

你可以使用初始化语法来创建特定类型的空数组（不设置任何初始值）。

var someInts = Int[]()
println("someInts is of type Int[] with \(someInts.count) items.")
// prints "someInts is of type Int[] with 0 items.”

或者如果上下文中已经说明了类型信息，比如函数参数或者一个已经定义过类型的变量或常量，那你就可以使用空得数组字面量[]还创建空数组。

someInts.append(3)
// someInts now contains 1 value of type Int
someInts = []
// someInts is now an empty array, but is still of type Int[]

var threeDoubles = Double[](count: 3, repeatedValue: 0.0)
// threeDoubles is of type Double[], and equals [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 is inferred as Double[], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

字典是一个可以存储同一类型的多个值的容器。各个值跟一个唯一的key关联，key在字典中是值的唯一标识。跟数组中的元素不同的是，字典中的元素没有特定的顺序。当你需要使用元素的标识来查找的时候可以使用字典，在现实世界中我们使用字典根据单词来查找定义。

Swift字典也是明确知道自己可以存储的key可value的类型。字典和OC的NSDictionary以及NSMutableDictionary不同，NSDictionary和NSMutableDictionary可以使用任何对象作为key和value，而且不需要提供这些对象的任何类型信息。在Swift中，一个特定的字典可以存储的key和value的类型总是要指明的，要么通过类型标注，要么通过类型推断。

Swift的字典类型写作Dictionary<KeyType, ValueType>，KeyType是可以用作字典Key的类型，ValueType是字典可以存储的value的类型。

唯一的限制是KeyType必须是hashable，也就是说他必须要提供一个另自己唯一表示的方式。Swift的所有基础类型（比如String，Int，Double和Bool）默认都是hashable，所以这些类型都可以作为字典的key。没有关联值的枚举成员默认也是hashable

字典字面值

你可以使用字典字面值来初始化字典，字典字面值跟前面的数组字面值语法类似。字典字面值是将一个或多个key-value对写成字典集合的简便方式。

一个key-value对是一个key与一个value的绑定。在字典字面值中，各个key-value用逗号隔开并被中括号包围，key与value用冒号隔开：

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

下面例子创建了一个字典来存储国际机场的名称：

var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]
字典airport被声明为Dictionary<String, String>类型，意思是”key类型为String,value类型也为String的字典“

NOTE 字典airports被声明为变量而不是常量，因为后面例子中还会向其中添加更多元素。

字典airports被使用包含两个key-value对的字典字面值初始化。第一对key是”TYO",value是”Tokyo“，第二对key是"DUB"，value是”Dublin“。

这个字典字面值包含两个字符串：字符串对。正好匹配变量airports声明的类型，所以使用字典字面值赋值被允许用来初始化字典airports。

也数组一样，如果你使用key和value保持一致的字典字面值来初始化字典的时候也不必要再写出字典的类型。airports的初始化可以使用下面的简写方式：

var airports = ["TYO": "Tokyo", "DUB": "Dublin"]
因为字典字面值中各个元素的key类型是一样的，各个元素的value类型也是一样的，所以swift可以推断出来Dictionary<String, String>就是用来初始化字典airport的正确类型。

获取和修改字典

你可以通过字典的属性或者方法或者下标语法来获取和修改字典。和数组一样，你可以使用count属性来查看字典中的元素个数。

println("The dictionary of airports contains \(airports.count) items.")
// prints "The dictionary of airports contains 2 items.

airports["LHR"] = "London"
// the airports dictionary now contains 3 items

airports["LHR"] = "London Heathrow"
// the value for "LHR" has been changed to "London Heathrow

updateValue(forKey:)方法返回字典value类型的可选值。比如上面存储字符串值的字典，该方法返回字符串可选值。如果更新前value存在，返回的可选值当中存储原来的value，如果不存在，返回的就是nil。

if let oldValue = airports.updateValue("Dublin International", forKey: "DUB") {
    println("The old value for DUB was \(oldValue).")
}
// prints "The old value for DUB was Dublin.”

if let airportName = airports["DUB"] {
    println("The name of the airport is \(airportName).")
} else {
    println("That airport is not in the airports dictionary.")
}
// prints "The name of the airport is Dublin International.”

airports["APL"] = "Apple International"
// "Apple International" is not the real airport for APL, so delete it
airports["APL"] = nil
// APL has now been removed from the dictionary

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.")
}
// prints "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

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

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

创建空字典

和数组一样，你可以使用初始化语法来创建特定类型的空字典：

var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers is an empty Dictionary<Int, String>

如果上下文已经提供了类型信息，就可以直接使用空字典字面值来创建空字典，空字典字面值写作[:]：

namesOfIntegers[16] = "sixteen"
// namesOfIntegers now contains 1 key-value pair
namesOfIntegers = [:]
// namesOfIntegers is once again an empty dictionary of type Int, String

3.可修改集合

数组和字典将多个元素存储到一个集合中。如果你创建了一个数组或者字典，并且赋值给一个变量，那么创建的集合就是可以修改的。也就是说你可以在集合创建以后添加更多地元素或者移除已有元素来改变集合的长度。反过来如果你把数组或者字典赋值给常量，那么这个数组或者字典就是不可变得，长度也不能改变。

对于字典来说，不可变星还以为这你不恩给你替换已有的key对应的value。不可变的字典内容一旦被设置就不能再改变。

对于数组来说不可变性有一点点不同。你还是不能做一些可能改变数组唱的的操作，但是你可以替换数组中已有的值。这样可以让Swift的数组在固定长度的时候提供更好地性能。

NOTE 当集合长度不需要改变的时候尽量要创建不可变的集合。这样Swift编译器可以优化你创建的集合的性能。

6.Swift教程翻译系列——Swift集合类型,布布扣,bubuko.com

6.Swift教程翻译系列——Swift集合类型

标签：ios   swift   数组   字典   集合   

原文地址：http://blog.csdn.net/tsingheng/article/details/32179147