Swift学习之路--Swift基础(六)

作者刘文涛
转载请注明出处

集合类型（Collection Types）

Swift 语言提供 Arrays 、Sets 和 Dictionaries 三种基本的集合类型用来存储集合数据。数组（Arrays）是有序数据的集。集合（Sets）是无序无重复数据的集。字典（Dictionaries）是无序的键值对的集。

Swift 语言中的 Arrays 、Sets 和 Dictionaries 中存储的数据值类型必须明确。这意味着我们不能把不正确的数据类型插入其中。同时这也说明我们完全可以对取回值的类型非常自信。

集合的可变性

如果创建一个 Arrays 、Sets 和 Dictionaries 并且把它分配成一个变量，这个集合将会是可变的。这意味着我们可以在创建之后添加更多或移除已存在的数据项，或者改变集合中的数据项。如果我们把 Arrays 、Sets 和 Dictionaries分配成常量，那么他就是不可变的，他的大小和内容都不能被改变。

注意：
在我们不需要改变集合的时候创建不可变集合是很好的实践。如此Swift编译器可以优化我们创建的集合。

数组

数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

数组的简单语法

写 Swift 数组应遵循像 Array<Element> 这样的形式，其中Element 是这个数组中唯一允许存在的数据类型。我们也可以使用像[Element]这样的简单语法。尽管两种形式在功能上是一样的，但是推荐较短的那种，而且在本文中都会使用这种形式来使用数组。

创建一个空数组

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

1
2
var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.") // 打印 "someInts is of type [Int] with 0 items."

注意，通过构造函数的类型，someInts 的值类型被推断为 [Int]。
或者，如果代码上下文中已经提供了类型信息，例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，他的写法很简单：

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

创建一个带有默认值的数组

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

1
2
var threeDoubles = Array(repeating:0.0, count: 3)
// threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]

通过两个数组相加创建一个数组

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

1
2
3
4
var fourDoubles = Array(repeating:2.5, count: 4)
// fourDoubles 被推断为 [Double]，等价于 [2.5, 2.5, 2.5, 2.5]
var sevenDoubles = threeDoubles + fourDoubles
// sevenDoubles 被推断为 [Double]，等价于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5, 2.5]

用数组字面量构造数组

我们可以使用数组字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。数组字面量是一系列由逗号分割并由方括号包含的数值：

1
[value 1, value 2, value 3]

下面这个例子创建了一个叫做 shoppingList 并且存储 String 的数组:

1
2
var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。

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

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

因为所有数组字面量中的值都是相同的类型，Swift 可以推断出 [String] 是 shoppingList 中变量的正确类型。

访问和修改数组

我们可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。

可以使用数组的只读属性 count 来获取数组中的数据项数量：

1
2
print("The shopping list contains \(shoppingList.count) items")
// // 输出 "The shopping list contains 2 items."(这个数组有2个项)

使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0 。

也可使用 append(_:) 方法在数组后面添加新的数据项：

1
shoppingList.append("Flour")

除此之外，使用加法赋值运算符( += )也可以直接在数组后面添加一个或多个拥有相同类型的数据项：

1
shoppingList += ["Baking Powder"]

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

1
2
var firstItem = shoppingList[0]
// 第一项是 Eggs

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

1
2
shoppingList[0] = "Six Eggs"
// shoppingList的第一项现在是 "Six eggs" 而不是 "Eggs"

还可以用下标一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。

1
shoppingList[1...3] = ["Bananas", "Apples"]

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

1
2
shoppingList.insert("Maple Syrup", at: 0)
// "Maple Syrup" 现在是这个列表中的第一项

类似的我们可以使用 remove(at:) 方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移 除并且返回这个被移除的数据项：

1
2
let mapleSyrup = shoppingList.remove(at: 0)
// mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"

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

如果我们只想把数组中的最后一项移除，可以使用 removeLast() 方法而不是 remove(at:) 方法来避免我们需要获取数组的 count 属性。

1
let apples = shoppingList.removeLast()

数组的遍历

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

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

如果我们同时需要每个数据项的值和索引值，可以使用 enumerated() 方法来进行数组遍历。enumerated() 返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：

1
2
3
4
5
 for (index, value) in shoppingList.enumerated() {
    print("Item \(String(index + 1)): \(value)")
}
//Item 1: Six Eggs
//Item 2: Bananas

集合 (Sets)

集合（set）用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要是或者希望确保每个元素只出现一次时，可以使用集合而不是数组。

集合类型的哈希值

一个类型为了存储在集合中，该类型必须是可哈希化的–也就是说，该类型必须提供一个方法来计算它的哈希值。一个哈希值是 Int 类型的，相等的对象哈希值必须相同，比如 a==b，因此必须 a.hashValue = b.hashValue。

Swift 的所有基本类型（比如 String，Int，Double和Bool）默认都是可哈希化的，可以作为集合的值的类型或者字典的键的类型。没有关联值的枚举成员值默认也是可哈希化的。

集合类型语法

Swift中的 Set类型被写为 Set<Element>，这里的Element 表示 Set 中允许存储的类型，和数组不同的是，集合没有等价的简化形式。

创建和构造一个空的集合

你可以通过构造器语法创建一个特定类型的空集合：

1
2
3
var letters = Set<Character>()
print("letters is of type Set<Character> with \(letters.count) items.")
//打印 letters is of type Set<Character> with 0 items.

此外，如果上下文提供了类型信息，比如作为函数的参数或者已知类型的变量或常量，我们可以通过一个空的数组字面量创建一个空的 Set :

1
2
3
4
letters.insert("a")
// letters 现在含有1个 Character 类型的值
letters = []
// letters 现在是一个空的 Set, 但是它依然是 Set<Character> 类型

用数组字面量创建集合

你可以使用数组字面量来构造 合，并且可以使用简化形式写一个或者多个值作为 合元素。

1
2
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// favoriteGenres 被构造成含有三个初始值的集合

一个 Set 类型不能从数组字面量中被单独推断出来，因此 Set 类型必须显式声明。然而，由于Swift的类型推断功能，如果你想使用一个数组字面量构造一个 Set 并且该数组字面量中的所有元素类型相同，那么你无须写出 Set 的具体类型。favoriteGenres 的构造形式可以采用简化的方式代替:

1
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]

访问和修改一个集合

你可以通过 Set 的属性和方法来访问和修改一个 Set 。
为了找出一个 Set 中元素的数量，可以使用其只读属性 count 。

使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0。

你可以通过调用 Set 的 insert(_:) 方法来添加一个新元素。

你可以通过调用 Set 的 remove(_:) 方法去删除一个元素，如果该值是该 Set 的一个元素则删除该元素并且返回被删除的元素值，否则如果该 Set 不包含该值，则返回 nil 。另外， Set 中的所有元素可以通过它的 removeAll() 方法删除。

1
2
3
4
5
6
7
8
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
if let removeGenre = favoriteGenres.remove("Rock") {
    print("\(removeGenre)? I`m over it")
}else {
    print("I never much cared for that.")
}
// 打印 "Rock? I'm over it."

使用 contains(_:) 方法去检查 Set 中是否包含一个特定的值:

1
2
3
4
5
6
if favoriteGenres.contains("Funk") {
    print("I get up on the good foot.")
}else {
    print("It's too funky in here.")
}
// 打印 "It's too funky in here."

遍历一个集合

你可以在一个 for-in 循环中遍历一个 Set中的所有值。

1
2
3
4
5
6
for genre in favoriteGenres {
    print("\(genre)")
}
//打印 
//Hip hop
//Classical

Swift 的 Set 类型没有确定的顺序，为了按照特定的顺序来遍历一个 Set 中的值可以使用 sorted() 方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符 ‘<’ 对元素进行比较的结果来确定。

1
2
3
4
5
for genre in favoriteGenres.sorted() {
    print("\(genre)")
}
// prints "Classical"
// prints "Hip hop"

集合操作

你可以高效地完成 Set 的一些基本操作，比如把两个集合组合到一起，判断两个集合共有元素，或者判断两个集合是否全包含，部分包含或者不相交。

集合基本操作

• 使用 intersection(_:) 方法根据两个 合中都包含的值创建的一个新的集合。

• 使用 symmetricDifference(_:) 方法根据在一个集合中但不在两个 合中的值创建一个新的集合。

• 使用 union(_:) 方法根据两个集合的值创建一个新的集合。

• 使用 subtracting(_:) 方法根据不在该集合中的值创建一个新的集合。

1
2
3
4
5
6
7
8
9
10
11
12
let oddDigits: Set = [1,3,5,7,9]
let evenDigits: Set = [0,2,4,6,8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
oddDigits.union(evenDigits).sorted()
//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.intersection(singleDigitPrimeNumbers).sorted()
//[3, 5, 7]
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
//[1, 9]
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
//[1, 2, 9]

集合成员关系和相等

• 使用“是否相等”运算符( == )来判断两个集合是否包含全部相同的值。

• 使用 isSubset(of:) 方法来判断一个集合中的值是否也被包含在另外一个集合中。

• 使用 isSuperset(of:) 方法来判断一个集合中包含另一个集合中所有的值。

• 使用 isStrictSubset(of:) 或者 isStrictSuperset(of:) 方法来判断一个集合是否是另外一个集合的子集合或者父集合并且两个集合并不相等。

• 使用 isDisjoint(with:) 方法来判断两个集合是否不含有相同的值(是否没有交集)。

1
2
3
4
5
6
7
8
9
10
let houseAnimals: Set = ["?","?"]
let farmAnimals: Set = ["?","?","?","?","?","?"]
let cityAnimals: Set = ["?","?"]
houseAnimals.isSubset(of: farmAnimals)
//true
farmAnimals.isSuperset(of: cityAnimals)
//true
farmAnimals.isDisjoint(with: cityAnimals)
//false

字典

字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key）,键作为字典中的这个值数据的标识符。和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典。

字典类型简化语法

Swift 的字典使用 Dictionary<Key, Value> 定义，其中 Key 是字典中键的数据类型， Value 是字典中对应于这些键所存储值的数据类型。
我们也可以用 [Key: Value] 这样简化的形式去创建一个字典类型。虽然这两种形式功能上相同，但是后者是首选，并且这本指导书涉及到字典类型时通篇采用后者。

创建一个空字典

我们可以像数组一样使用构造语法创建一个拥有确定类型的空字典：

1
2
var namesOfIntegers = Int: Sring
// namesOfIntegers是一个空的[Int: String]字典

如果上下文已经提供了类型信息，我们可以使用字典字面量来创建一个空字典，记作：[:]

1
2
3
4
namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个键值对
nameOfIntegers = [:]
// namesOfIntegers 又成为了一个空的[Int: String]字典

用字典字面量创建字典

我们可以使用字典字面量来构造字典，这和我们刚才介绍过的数组字面量拥有相似语法。字典字面量是一种将一个或多个键值对写作 Dictionary 合的快捷途径。

1
var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

airports 字典被声明为一种[String: String]类型，这意味着这个字典的键和值都是String类型。

访问和修改字典

我们可以通过字典的方法和属性来访问和修改字典，或者通过使用下标语法。
和数组一样，我们可以通过字典的只读属性 count 来获取某个字典的数据项数量。
使用布尔属性 isEmpty 作为一个缩写形式去检查 count属性是否为 0。
我们也可以在字典中使用下标语法来添加新的数据项。可以使用一个恰当类型的键作为下标索引，并且分配恰当类型的新值:

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

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

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

作为另一种下标方法，字典的 updateValue(_:forKey:) 方法可以设置或更新特定键对应的值。在键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和上面的下标方法不同的，updateValue(_:forKey:) 这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。
updateValue(_:forKey:) 方法会返回对应值的类型的可选值。举例来说:对于存储 String 值的字典，这个函数会 返回一个 String? 或者“可选 String ”类型的值。
如果有值存在于更新前，则这个可选值包含了旧值，否则它将会是nil.

1
2
3
4
let oldValue = airports.updateValue("Dublin Airport", forKey: "DUBv") {
    print("The old value for DUB was (oldValue).")
}
// 输出 "The old value for DUB was Dublin."

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

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

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

1
if let removedValue = airports. removeValue(forKey: "DUB") {
     print("The removed airport's name is (removedValue).")
 } else {
     print("The airports dictionary does not contain a value for DUB.")
 }
 // prints "The removed airport's name is Dublin Airport."

字典遍历

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

1
2
3
4
5
for (airportCode, airportName) in airports {
    print("\(airportCode): \(airportName)")
}
//DUB: Dublin
//YYZ: Toronto Pearson

通过访问keys或者values属性，我们也可以遍历字典的键或者值：

1
2
3
4
5
6
7
8
9
10
for airportCode in airports.keys {
    print("Airport code: \(airportCode)")
}
// Airport code: DUB
// Airport code: YYZ
for airportName in airports.values {
    print("Airport name: \(airportName)")
}
// Airport name: Dublin
// Airport name: Toronto Pearson

Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值，可以对字典的keys或values属性使用 sorted()方法。

赏

谢谢打赏

支付宝

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    2、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: true
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

iOS开发工程师一枚<br></br>爱生活，爱编码<br></br>All or nothing,now or never!