- Swift 语言提供 Arrays、Sets 和 Dictionaries 三种基本的集合类型用来存储集合数据,存储的数据值类型必须明确.
- 如果创建一个 Arrays、Sets 或 Dictionaries 并且把它分配成一个变量，这个集合将会是可变的。 分配成常量，那么它就是不可变的。
数组（Arrays）是有序数据的集。
集合（Sets）是无序无重复数据的集。
字典（Dictionaries）是无序的键值对的集。
数组 (Arrays)
创建数组
//一个由特定数据类型构成的空数组
var someInts1 = [Int]()
var someInts11: [Int] = []
// 创建一个带有默认值的数组
var someInts2 = [Int](repeating: 0, count: 3)
// 用数组字面量构造数组
var someInts3:[Int] = [10, 20, 30]
// 通过两个数组相加创建一个数组 (同类型)
var otherIntArray = someInts2 + someInts3
访问和修改数组
// 使用数组的只读属性 count 来获取数组中的数据项数量
print(otherIntArray.count)
// 使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0
if otherIntArray.isEmpty {
print("empty.")
} else {
print("not empty.")
}
// 使用append(_:) 方法在数组后面添加新的数据项
otherIntArray.append(100)
// 使用加法赋值运算符（+=）也可以直接在数组后面添加一个或多个拥有相同类型的数据项
otherIntArray += [200]
// 使用数组的索引来访问数组的元素
var someVar = otherIntArray[4]
// 使用标来改变某个已有索引值对应的数据值
otherIntArray[0] = 666
print(otherIntArray)
// 使用数组的 insert(_:at:) 方法来在某个具体索引值之前添加数据项
(otherIntArray).insert(777, at: 1)
print(otherIntArray)
// 使用 remove(at:) 方法来移除数组中的某一项
let newList = otherIntArray.remove(at: 0)
print(otherIntArray)
// 数组中的最后一项移除
let newlist1 = otherIntArray.removeLast()
print(otherIntArray)
数组遍历
// 使用 for-in 循环来遍历所有数组中的数据项
for item in otherIntArray {
print(item)
}
// 同时需要每个数据项的值和索引值，可以使用 enumerated() 方法来进行数组遍历。enumerated() 返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历
for (index, value) in otherIntArray.enumerated() {
print("Item \(String(index + 1)): \(value)")
}
字典
- 字典是一种存储多个相同类型的值的容器。每个值（value）都关联唯一的键（key），需要通过标识符（键）访问数据的时候使用字典。
- 字典使用 Dictionary<Key, Value> 定义，其中 Key 是字典中键的数据类型，Value 是字典中对应于这些键所存储值的数据类型。
- 可以用 [Key: Value] 这样简化的形式去创建一个字典类型。
// 可以像数组一样使用构造语法创建一个拥有确定类型的空字典
var someDict = [KeyType: ValueType]()
var someDict1 = [Int: String]()
// 用字典字面量创建字典
var someDict2: [String: String] = [key 1: value 1, key 2: value 2, key 3: value 3]
var someDict3: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
var someDict4:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
访问和修改字典
// 可以像数组一样使用构造语法创建一个拥有确定类型的空字典
//var someDict = [KeyType: ValueType]()
var someDict1 = [Int: String]()
// 用字典字面量创建字典
//var someDict2: [String: String] = [key 1: value 1, key 2: value 2, key 3: value 3]
var someDictString: [String: String] = ["XX": "AAA", "YY": "BBB"]
var someDictIntString:[Int:String] = [1:"One", 2:"Two", 3:"Three"]
//访问和修改字典
// 使用字典的方法和属性来访问和修改字典，或者通过使用下标语法
// 和数组一样，使用通过字典的只读属性 count 来获取某个字典的数据项数量
print(someDictString.count)
// 使用布尔属性 isEmpty 作为一个缩写形式去检查 count 属性是否为 0
if someDictString.isEmpty {
print("empty.")
} else {
print("not empty.")
}
// 使用字典中使用下标语法来添加新的数据项
someDictString["ZZ"] = "CCC"
print(someDictString)
// 使用下标语法来改变特定键对应的值
someDictString["ZZ"] = "DDD"
print(someDictString)
// 使用字典的 updateValue(_:forKey:) 方法可以设置或者更新特定键对应的值,在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值
someDictString.updateValue("我是新的AA", forKey: "XX")
print(someDictString)
someDictString.updateValue("我是新的KK", forKey: "KK")
print(someDictString)
//使用下标语法来在字典中检索特定键对应的值 如果有字典的下标访问会返回对应值的类型的可选值 否则将返回 nil
if let someX = someDictString["XX"] {
print(someX)
} else {
print("NO")
}
// 使用下标语法来通过给某个键的对应值赋值为 nil 来从字典里移除一个键值对
print(someDictString)
someDictString["ZZ"] = nil
print(someDictString)
// 使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值，如果不存在返回 nil
if let removedValue = someDictString.removeValue(forKey: "KK") {
print(removedValue)
print(someDictString)
} else {
print("NO")
}
字典遍历
//使用 for-in 循环来遍历某个字典中的键值对
for (key, value) in someDictIntString {
print("字典 key \(key) - 字典 value \(value)")
}
// 使用enumerate()方法来进行字典遍历，返回的是字典的索引及 (key, value) 对
for (key, value) in someDictIntString.enumerated() {
print("字典 key \(key) - 字典 (key, value) 对 \(value)")
}
// 通过访问 keys 或者 values 属性，我们也可以遍历字典的键或者值
for intKey in someDictIntString.keys {
print("key: \(intKey)")
}
for stingValue in someDictIntString.values {
print("value: \(stingValue)")
}
// 字典的键集合或者值集合 可以直接使用 keys 或者 values 属性构造一个新数组
let keyAarray = [Int](someDictIntString.keys)
let valuesArray = [String](someDictIntString.values)
集合（Sets）
- Set 集合的三个特性：
确定性：给定一个集合，任给一个元素，该元素或者属于、或者不属于该集合，二者比居其一。
互斥性：一个集合中，任意两个元素都认为是不相同的，即每个元素只能出现一次。
无序性：一个集合中，每个元素的地位都是相同的，元素之间是无序的。
- Set 也是通过哈希表实现的，集合中的元素也必须满足 Hashable，序列中不能出现重复元素时。
- 集合也支持我们已经见过的那些基本操作用 for 循环进行迭代，对它进行 map 或 filter 操作。
创建集合
// 创建一个空集合
var letters = Set<Character>()
// 插入数据
letters.insert("a")
// 置空
letters = []
// 用数组字面量创建集合
var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
// 一个 Set 类型不能从数组字面量中被单独推断出来，因此 Set 类型必须显式声明
var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
访问和修改一个集合
// 通过 Set 的属性和方法来访问和修改一个 Set
// 只读属性 count
print("I have \(favoriteGenres.count) favorite music genres.")
// 布尔属性 isEmpty
if favoriteGenres.isEmpty {
print("As far as music goes, I'm not picky.")
} else {
print("I have particular music preferences.")
}
// 调用 Set 的 insert(_:)添加一个新元素：
favoriteGenres.insert("Jazz")
// 调用 Set 的 remove(_:) 方法去删除一个元素
// 如果该值是该 Set 的一个元素则删除该元素并且返回被删除的元素值，否则如果该 Set 不包含该值，则返回 nil。
if let removedGenre = favoriteGenres.remove("Rock") {
print("\(removedGenre)? I'm over it.")
} else {
print("I never much cared for that.")
}
// Set 中的所有元素可以通过它的 removeAll() 方法删除。
// 使用 contains(_:) 方法去检查 Set 中是否包含一个特定的值。
if favoriteGenres.contains("Funk") {
print("I get up on the good foot.")
} else {
print("It's too funky in here.")
}
遍历一个集合
// for-in 循环中遍历一个 Set
for genre in favoriteGenres {
print("\(genre)")
}
// Swift 的 Set 类型没有确定的顺序，为了按照特定顺序来遍历一个 Set 中的值可以使用 sorted() 方法，它将返回一个有序数组，这个数组的元素排列顺序由操作符'<'对元素进行比较的结果来确定。
for genre in favoriteGenres.sorted() {
print("\(genre)")
}
集合基本运算
image.png
- intersection(_:) 创建一个新的集合，取两个集合共有的值。
- symmetricDifference(_:) 创建一个新的集合，取两个集合独有但不共有的值。
- union(_:) 创建一个新的集合，取两个集合所有的值。
- subtracting(_:) 创建一个新的集合，取指定集合不包含的值。
let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]
oddDigits.intersection(evenDigits).sorted()
// []
oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted()
// [1, 2, 9]
oddDigits.union(evenDigits).sorted()
// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
oddDigits.subtracting(singleDigitPrimeNumbers).sorted()
// [1, 9]
集合关系跟同等性
image.png
- 三个集合
a，b和c的关系，重叠区域代表集合的共同元素。a是b的超集，因为a包含b的所有元素。相反的b是a的子集，因为b的所有元素都被a包含。a和c是不相交的，因为没有共同的元素。 - 使用等于运算符(
==)判断两个集合是否包含所有的同样值 - 使用
isSubset(of:)方法判断一个集合的所有值是否都被一个指定集合包含 - 使用
isSuperset(of:)方法判断一个集合是否包含一个指定集合的所有值 - 使用
isStrictSubset(of:)和isStrictSuperset(of:)方法判断一个集合是否是一个指定集合的子集或超集，但不相等 - 使用
isDisjoint(with:)方法判断两个集合是否没有相同的值
let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]
houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true
Set 和 NSSet 之间的桥接
- 使用类型转换操作符 as 可完成Set和NSSet之间的桥接
- 为了完成Set到NSSet的桥接，要求Set中的元素必须是class类型，符合@objc protocol的类型或者可以与Foundation中的类型相桥接的类型（String， Int，Float等）
- Set到NSSet的桥接的时间复杂度和空间复杂度总是O(1), 但当Set中的元素不是class类型也不是符合@objc protocol的类型时，Set中的元素到OC中相关类型的桥接总是发生在第一次访问Set中的元素时，时间复杂度为O(n)。
- NSSet到Set的桥接会调用NSSet的copy(with:)方法得到NSSet的不可修改的副本（时间复杂度不确定）并进行额外的Swift的统计工作（时间复杂度为O(1)），如果NSSet已经是不可修改的，那么copy(with:)方法返回同一个set（时间复杂度为O(1)），并且与桥接后得到的Set共享同一存储空间，采用copy-on-write的方法对该内存存储进行优化。
网友评论