Swift中文教程(四) 集合类型

Swift 提供两种集合类型来存储集合,数组和字典。数组是一个同类型的序列化列表集合。字典是一个能够使用类似于键的唯一标识符来获取值的非序列化集合。

 

在Swift中,数组和字典的键和值都必须明确它的类型。这意味这数组和字典不会插入一个错误的类型的值,以致于出错。这也意味着当你在数组和字典中取回数值的时候能够确定它的类型。
Swift 使用确定的集合类型可以保证代码工作是不会出错,和让你在开发阶段就能更早的捕获错误。
note:
Swift的数组 储存不同的类型会展示出不同的行为,例如变量,常量或者 函数和方法。更多的信息参见Mutability of Collections and Assignment 和 Copy Behavior for Collection Types.

 

1、数组
数组是储存同类型不同值的序列化列表。同样的值可以在数组的不同位置出现多次。

Swift数组是储存确定的值,这个Objective-C中的NSArray和NSMutableArray类是有区别的。因为它们是储存各种的 对象,而且并不提供返回任何有关对象的具体信息。在Swift中,无论是确定的声明,还是隐式的声明,数组是非常确定它自身是储存什么样的类型,而且,它 并不一定要求储存的是类对象。所以Swift数组是类型安全的,因为它一直都确定它自身所能包含的值。

 

数组的简略语法
定义数组的完整写法是Array<SomeType>。其中SomeType是你想要包含的类型。你也可以使用类似于SomeType[]这样的简略语法。虽然这两种方法在功能上是相同的。但是我们更推荐后者,而且它会一直贯穿于本书。

 

数组实量(Array Literals)
你可以用一个数组实量(Array Literals)来初始化一个数组,它是用简略写法来创建一个包含一个或多个的值的数组。一个数组实量(Array Literals)是由它包含的值,“,”分隔符 已经包括以上内容的中括号对“[]”组成:

C代码

[value 1, value 2, value 3]

 

下面的例子创建一个叫shoppinglist,储存字符串(String)类型的数组。

C代码

    var shoppingList: String[] = ["Eggs", "Milk"]  
    // 使用两个初始化参数来初始化shoppingList

 

shoppinglist变量被定义为字符串(String)类型的数组,写作String[]。因为这个数组被确定为字符串类型 (String),所以它只能储存字符串(String)类型的值。在这里,用两个字符串类型的值(”Eggs” and “Milk”)和数组实量(Array Literals)的写法来初始化shoppingList数组。

 

注意
shoppingList数组是被定义为一个变量(使用var 标识符)而不是常量(使用let 标识符),所以在下面的例子可以直接添加元素。

 

在这个例子中,数组实量(Array Literals)只包含两个字符串类型的值,这符合了shoppingList变量的定义(只能包含字符串(String)类型的数组),所以被分配的数组实量(Array Literals)被允许用两个字符串类型的值来初始化。

 

得益于Swift的类型推断,当你用相同类型的值来初始化时,你可以不写明类型。初始化shoppingList可以用下面这个方法来代替。

C代码

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

 

因为数组实量(Array Literals)中所有的值都是同类型的,所以Swift能够推断shoppingList的类型为字符串数组(String[])。

 

读取和修改数组
你可以通过方法和属性,或者下标来读取和修改数组。

通过只读属性count来读取数组的长度;

C代码

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

 

通过一个返回布尔类型的isEmpty属性检查数组的长度是否为0

C代码

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

 

在数组末尾增加一个元素可以通过append方法

C代码

    shoppingList.append("Flour")  
    // shoppingList 现在包含3个元素

 

甚至,还可以用(+=)操作符来把一个元素添加到数组末尾

C代码

shoppingList += "Baking Powder"  
// shoppingList 现在包含4个元素

 

你也可以用(+=)操作符来把一个数组添加到另一个数组的末尾

C代码

    shoppingList += ["Chocolate Spread", "Cheese", "Butter"]  
    // shoppingList 现在包含7个元素

 

从数组中取出一个值可以使用下标语法。如果你知道一个元素的索引值,你可以数组名后面的中括号中填写索引值来获取这个元素

C代码

var firstItem = shoppingList[0]  
// firstItem 等于 “Eggs"

 

注意,数组的第一个元素的索引值为0,不为1,Swift的数组总是索引0;

你可以使用下标语法通过索引修改已经存在的值。

C代码

    shoppingList[0] = "Six eggs"  
    //列表中的第一个值等于"Six eggs" 而不等于 “Eggs"

 

你可以使用下标语法一次性改变一系列的值,尽管修改的区域远远大于要修改的值。在下面的雷子中, 替换掉 “Chocolate Spread”, “Cheese”,”Butter”,”Bananas”,”Apples”:

C代码

shoppingList[4...6] = ["Bananas", "Apples"]  
// shoppingList 现在包含6个元素

 

注意,你不能使用下标语法在数组中添加一个元素,如果你尝试使用下标语法来获取或者设置一个元素,你将得到一个运行时的错误。尽管如此,你可以通过 count属性验证索引是否正确再使用它。当count为0时(意味着数组为空),则count-1超出了索引的有效范围,因为数组的索引总是从0开始。

在一个特定的索引位置插入一个值,可以使用insert(atIndex:)方法

C代码

    shoppingList.insert("Maple Syrup", atIndex: 0)  
    // shoppingList 现在包含7个元素  
    // "Maple Syrup" 在数组的第一位

 

这里调用insert方法指明在shoppingList的索引为0的位置中插入一个新元素 “Maple Syrup”

同理,你可以调用removeAtIndex方法移除特定的元素。这个方法移除特定索引位置的元素,已经返回这个被移除的元素(尽管你并不关心这个返回值)。

C代码

    let mapleSyrup = shoppingList.removeAtIndex(0)  
    // 索引位置为0的元素被移除   
    // shoppingList 现在包含6个元素, 不包括 Maple Syrup  
    // mapleSyrup 常量等于被移除的 "Maple Syrup" 字符串

 

当元素被移除的,数组空缺的位置将会被填补,所以现在索引位置为0的元素再一次等于”Six eggs”:

C代码

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

 

如果你从数组中移除最后一个元素,使用removeLast方法比removeAtIndex更方便,因为后者需要通过count属性计算数组的长度。和removeAtIndex方法一样,removeLast会返回被移除的元素。

C代码

    let apples = shoppingList.removeLast()  
    //元素的最后一个元素被移除  
    // shoppingList 现在包含5个元素,不包括 cheese  
    // apples 常量 现在等于被移除的 "Apples" string

 

遍历数组
可以使用for-in循环来遍历数组中的值

C代码

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

 

如果需要每一个元素的整形的索引值,使用enumerate函数代替会更方便,enumerate函数对于每一个元素都会返回一个包含元素的索引和值的元组(tuple)。你可以在遍历部分分解元祖并储存在临时变量或者常量中。

C代码

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

 

如需更多for-in 循环信息, 参见 For Loops.

 

创建和初始化数组
创建一个空的数组和确定的类型(不包含初始化值)使用的初始化语法:

C代码

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

 

注意,someInt变量被确定为Int[],因为它使用生成Int[]的初始化方法。

或者,如果上下文(context)已经提供类型信息,例如函数参数或者已经确定类型的常量和变量,你可以从空的数组实量(Array Literals)创建一个空数组,写作[](空的中括号对)。

C代码

    someInts.append(3)  
    // someInts 现在包含1个Int型的元素  
    someInts = []  
    // someInts 现在是一个空的数组, 但是类型仍然为Int[];

 

Swift数组类型也提供初始化方法来创建确定长度和提供默认数值的数组。你可以通过这个初始化方法增加一个新的数组,元素的数量成为count,合适的默认值为repeatedValue

C代码

var threeDoubles = Double[](count: 3, repeatedValue: 0.0)  
// threeDoubles 的类型为 Double[], 以及等于 [0.0, 0.0, 0.0]

 

得益于类型推断,你并不需要指明这个数组储存的类型就能使用这个初始化方法,因为它从默认值中就能推断出来。

C代码

    var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)  
    // anotherThreeDoubles 被推断为 Double[], 以及等于 [2.5, 2.5, 2.5]

 

最后,你可以使用(+)操作符就能创建一个新的数组,把两个存在的数组添加进来
这个新的数组类型从你添加的两个数组中推断出来

C代码

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

 

2、字典

字典是储存同一类型但是不同值的容易。每一个值都对应这一个唯一的键(Key),就像是字典内的每一个值都有一个标识符。和数组内的元素是由区别 的,字典内的元素是没有特殊的序列的。当你需要根据标识符来查找批量的值时,就可以使用字典。同样的,真实的物品字典常常用来当作查找特定字典的标识符。

 

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

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

 

唯一的限制就是KeyType必须是可哈希的(hashable)——就是提供一个形式让它们自身是独立识别的。Swift的所有基础类型(例如字 符串(String),整形(Int),双精度(Double)和布尔(Bool))在默认是可哈希的(hashable),和这些类型都常常用语当作字 典的键。枚举成员值不需要协助值(associated values)(具体描述在 Enumerations)也是因为它们默认也是可哈希的(hashable)。

 

字典实量(Dictionary Literals)
你可以直接用一个字典实量(Dictionary Literals)初始化一个字典。和前面定义一个数组实量(Array Literals)的语法一样。字典实量(Dictionary Literals)就是使用简略写法直接写一个或者多个的键值对来定义一个字典。

 

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

C代码

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

 

在下面的例子,将会创建一个字典来储存国际机场的名字。在这个字典里面,键是三个字的国际航空运送协会代码,以及它的值是机场的名称:

C代码

var airport :Dictionary<String, String> = ["TYO": "Tokyo", "DUB": “Dublin"]

 

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

 

注意
airport字典是被定义为一个变量(使用var 标识符)而不是常量(使用let 标识符),所以在下面的例子可以直接添加元素。

 

airport字典使用一个包含两个键值对的字典实量(Dictionary Literals)来初始化。第一对由一个叫“TYO”的键和一个叫“Tokyo”的值,第二对有一个叫“DUB”的键和一个叫“Dublin”的值。

 

这个字典实量(Dictionary Literals)包含两个字符串(String):字符串对。这符合airport变量定义的类型(一个字典只包括字符串(String)键和字符串 (String)值),所以在分配字典实量(Dictionary Literals)的时候被允许作为airport字典的两个初始化元素。

 

和数组一样,如果你初始化一个字典的时候使用相同的类型,你可以不指明字典的类型。
airport初始化可以用下面这个简略写法来代替:

C代码

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

 

因为所有的键在字面上都是相同的类型,同样,所有的值也是同样的类型,所以Swift可以推断为Dictionary<String, String>是airports字典的正确类型。

 

读取和修改字典
你可以通过属性,方法或者下标来读取和修改字典。和数组一样,你使用只读的count属性来检查字典(Dictionary)包含多少个元素。

C代码

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

 

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

C代码

airports["LHR"] = "London"  
//  airports dictionary 现在有 3 items

 

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

C代码

    airports["LHR"] = "London Heathrow"  
    //"LHR" 的值已经被改变为 "London Heathrow"

 

同样, 使用字典的updateValue(forKey:) 方法去设置或者更新一个特定键的值 . 和上面的下标例子一样, updateValue(forKey:) 方法如果键不存在则会设置它的值,如果键存在则会更新它的值, 和下标不一样是, updateValue(forKey:) 方法 如果更新时,会返回原来旧的值rThis enables you to 可以使用这个来判断是否发生了更新。

C代码

    updateValue(forKey:) 方法返回一个和字典的值相同类型的可选值. 例如,如果字典的值的类型时String,则会返回String? 或者叫“可选String“,这个可选值包含一个如果值发生更新的旧值和如果值不存在的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."

 

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

C代码

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."

 

你可以使用下标语法把他的值分配为nil,来移除这个键值对。

C代码

    airports["APL"] = "Apple International"  
    // "Apple International" 不是 APL的真实机场,所以删除它  
    airports["APL"] = nil

 

// APL 已经从字典中被移除
同样,从一个字典中移除一个键值对可以使用removeValueForKey方法,这个方法如果存在键所对应的值,则移除一个键值对,并返回被移除的值,否则返回nil。

C代码

    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循环来遍历字典的键值对。字典中的每一个元素都会返回一个元祖(tuple),你可以在循环部分分解这个元祖,并用临时变量或者常量来储存它。

C代码

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

 

更多有关for-in 循环的信息, 参见 For Loops.
你也可以读取字典的keys属性或者values属性来遍历这个字典的键或值的集合。

C代码

    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

 

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

C代码

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

 

注意
Swift中的字典类型是非序列化集合,如果你需要序列化取回键,值,或者键值对,遍历字典不具体叙述。

 

创建一个空字典
和字典一样,你可以使用确定类型的语法创建一个空的字典。

C代码

    var namesOfIntegers = Dictionary<Int, String>()  
    // namesOfIntegers 是一个空的 Dictionary<Int, String> 类型的字典

 

这个例子创建一个Int,String类型的字典来储存可读性较好的整数值。它的键是Int类型,以及它们的值是String类型。
如果 上下文(context )中已经提供类型信息,可用一个字典实量(Dictionary Literal)创建一个空的字典,写作[;](由一对[]包含一个冒号:)

C代码

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

 

注意
在这个场景,Swift数组和字典类型是一个内置的集合。更多的内置类型和集合参见Generics

 

3、可变集合类型

数组和字典都是在一个集合中一起储存不同的变量.如果你创建一个数组或者字典,再包含一个变量,创建的这个变量被称为可变的(mutable) 这意味这,你可以在创建之后增加更多的元素来改变这个集合的长度,或者移除已经包含的。 相反的, 如果你把一个数组或者字典定义为常量,则这个数组或者字典不是可变的,他们的长度并不能被改变。
在字典中,不可变也意味着你不能替换已经存在的键的值。一个不可变字典,一旦被设置就不能改变。
数组的不可变有一点点的不同。然而,你仍然不能做任何有可能修改不可变数组的行为。但是你可以重新设置一个已经存在的索引,这使得当Swift的数组的长度确定时,能更好地优化数组的性能。
拥有可变行为的数组也影响着数组实例的分配和修改,更多内容参见Assignment and Copy Behavior for Collection Types.
注意
在所有的例子中,这是一个好的练习去创建不可变集合,当数组的长度不需要被改变。
我确信Swift编译器能优化好你所创建的集合。

 

感谢翻译小组成员:李起攀(微博)、若晨(微博)、YAO、粽子、山有木兮木有枝、渺-Bessie、墨离、CXH、Tiger大顾(微博)
本文由翻译小组成员原创发布,个人转载请注明出处和原始链接,商业转载请联系我们~ 感谢您对我们工作的支持~

 

转自:http://letsswift.com/2014/06/collection-types/