目录

• 版本
• 简介
• Array
• Set
• Dictionary

版本

Xcode 11.0
Swift 5.1

简介

1. 简介
Swift三种基本集合类型:
数组(Array): 使用有序列表存储同一类型的多个值, 相同的值可以出现在不同位置中.
集合(Set): 存储相同类型并且没有确定顺序的值, 每个元素只出现一次.
字典(Dictionary): 使用无序的键值对存储相同类型的键和相同类型的值, 每个值(value)都关联唯一的键(key).

集合类型.png
Swift 中的数组、集合和字典必须明确其中保存的键和值类型，这样就可以避免插入一个错误数据类型的值。同理，对于获取到的值你也可以放心，其数据类型是确定的。

2. 可变性
不同于OC中的NSMutableArray/NSMutableDic/NSMutableSet, Swift中的集合类型使用let标识符则为不可变的(常量), 使用var修饰则为可变的(变量).

3. 语法
数组的完整写法为 Array<Element>，其中 Element 是这个数组中唯一允许存在的数据类型。也可以使用像 [Element] 这样的简单语法。
集合的完整写法为 Set<Element>，这里的 Element 表示集合中允许存储的类型。和数组不同的是，集合没有等价的简化形式。
字典的完整写法为 Dictionary<Key, Value> ，其中 Key 是一种可以在字典中被用作键的类型，Value 是字典中对应于这些键所存储值的数据类型。你也可以用 [Key: Value] 这样简化的形式去表示字典类型。

类型推断
在第二章节基础部分中我们提到, Swift是具有类型推断机制的. 编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
比如

var arr4 = ["one", "two"]
// arr4会被推断为[String]类型

Array

1. 创建

// 1. 创建空数组
var arr1 = [Int]()
// 2. 创建带有默认值数组
var arr2 = Array(repeating: 6, count: 3)
// 3. 通过两个数组相加创建一个数组
var arr3 = arr1 + arr2
// 4. 用数组字面量构造数组
//var arr4: [String] = ["one", "two"]
var arr4 = ["one", "two"]

/*
[]
[6, 6, 6]
[6, 6, 6]
["one", "two"]
*/

2. 访问和修改

var arr5 = [1, 2, 3]

// 查询数量
print(arr5.count)
// 3

// 判断为空
print(arr5.isEmpty)
// false

// 查询是否存在某元素
print(arr5.contains(2))
// true

// 后尾添加
arr5.append(4)
print(arr5)
// [1, 2, 3, 4]

// 后尾批量添加
arr5 += [5, 6]
print(arr5)
// [1, 2, 3, 4, 5, 6]

// 访问对应下标元素
print(arr5[2])
// 3

// 修改对应下标元素
arr5[0] = 88
print(arr5)
// [88, 2, 3, 4, 5, 6]

// 批量修改连续下标元素, 即使新数据与原数据数量不一致
arr5[1...4] = [88, 88]
print(arr5)
// [88, 88, 88, 6]

// 插入一个元素
arr5.insert(66, at: 3)
print(arr5)
[88, 88, 88, 66, 6]

// 移除一个元素
arr5.removeLast()
print(arr5)
// [88, 88, 88, 66]
arr5.remove(at: 3)
print(arr5)
// [88, 88, 88]

3. 遍历

var arr6 = ["one", "two", "three", "four", "five"]

// 遍历值
for value in arr6 {
    print(value)
}

/*
one
two
three
four
five
*/

// 遍历索引和对应的值
for (index, value) in arr6.enumerated() {
    print("index:\(index) value:\(value)")
}

/*
index:0 value:one
index:1 value:two
index:2 value:three
index:3 value:four
index:4 value:five
*/

Set

1. 创建

// 1. 创建空集合
var sets1 = Set<String>()
// 2. 用数组字面量构造集合
var sets2: Set<Int> = [11, 22, 33, 44, 55]

/*
[]
[55, 11, 33, 44, 22]
*/

注意: 一个集合类型不能从数组字面量中被直接推断出来，因此 Set 类型必须显式声明。

2. 访问和修改
与数组操作大同小异.

3. 遍历
因为集合Set是无序的, 所以遍历出的结果也是无序的. 如果想要值按照一个特定的顺序遍历出来, 可以使用 sorted() 方法.

var sets3: Set<String> = ["a", "b", "c", "d", "e"]

// 无序遍历
for value in sets3 {
    print(value)
}
/*
 e
 c
 d
 b
 a
 */

// 有序遍历
for value in sets3.sorted() {
    print(value)
}
/*
 a
 b
 c
 d
 e
 */

4. 基本集合操作
下面的插图描述了两个集合 a 和 b，以及通过阴影部分的区域显示集合各种操作的结果。

基本几何操作.png

• 使用 intersection(_:) 方法根据两个集合的交集创建一个新的集合。
• 使用 symmetricDifference(_:) 方法根据两个集合不相交的值创建一个新的集合。
• 使用 union(_:) 方法根据两个集合的所有值创建一个新的集合。
• 使用 subtracting(_:) 方法根据不在另一个集合中的值创建一个新的集合。

Dictionary

1. 创建

// 1. 创建空字典
var dic1 = [String: Int]()
// 2. 用字典字面量创建字典
//var dic2: [String: Int] = ["one": 1, "two": 2, "three": 3]
var dic2 = ["one": 1, "two": 2, "three": 3]

/*
[:]
["two": 2, "one": 1, "three": 3]
*/

2. 访问和修改

var dic3 = [1: "一", 2: "二", 3: "三"]

// 访问某个下标对应值
// 因为有可能请求的键没有对应的值存在，字典的下标访问会返回对应值类型的可选类型。
if let value = dic3[3] {
    print(value)
}else {
    print("empty")
}

// 添加键值对
dic3[4] = "四"
print(dic3)
// [3: "三", 1: "一", 2: "二", 4: "四"]

// 修改键值对 (法1)
dic3[2] = "二二"
print(dic3)
// [3: "三", 1: "一", 2: "二二", 4: "四"]

// 修改键值对 (法2)
dic3.updateValue("二二二", forKey: 2)
print(dic3)
// [3: "三", 1: "一", 2: "二二二", 4: "四"]

// 移除键值对 (法1)
dic3[4] = nil
print(dic3)
// [3: "三", 2: "二二二", 1: "一"]

// 移除键值对 (法2)
dic3.removeValue(forKey: 2)
print(dic3)
// [3: "三", 1: "一"]

注意: 上面的方法2与下标语法不同的是, updateValue(_:forKey:) 这个方法返回更新值之前的原值, 这样使得你可以检查更新是否成功; removeValue(forKey:) 这个方法返回被移除的值或者在没有对应值的情况下返回 nil.

遍历

var dic4 = [1: "one", 2: "two", 3: "three", 4: "four", 5: "five"]

// 遍历键 (无序)
for key in dic4.keys {
    print("key: \(key)")
}
/*
 key: 3
 key: 4
 key: 5
 key: 1
 key: 2
 */

// 遍历键 (有序)
for key in dic4.keys.sorted() {
    print("key: \(key)")
}
/*
 key: 1
 key: 2
 key: 3
 key: 4
 key: 5
 */

// 遍历值 (无序)
for value in dic4.values {
    print("value: \(value)")
}
/*
 value: three
 value: four
 value: five
 value: one
 value: two
 */

// 遍历值 (有序)
for value in dic4.values.sorted() {
    print("value: \(value)")
}
/*
 按字符逐个排序
 value: five
 value: four
 value: one
 value: three
 value: two
 */

// 遍历键和值
for (key, value) in dic4 {
    print("key:\(key) value:\(value)")
}
/*
 key:3 value:three
 key:4 value:four
 key:5 value:five
 key:1 value:one
 key:2 value:two
 */