#4 集合类型

Swift提供了3种常用的集合类型，都实现了泛型集合：

Array: 有序数据集合
Set: 无序，确保每个元素只出现一次，和JS中的Set类似
Dictionary: 字典，类似JS中的对象，swift中的字典使用 [key: value] 这种形式

1.Array

创建方式：

#1
var someInts = [Int]()

#2
var someInts: [Int] = []
var someInts: [Int] = [1, 2, 3]

#3 类型推断
# 自动推断someInts为 [Int] 类型
var someInts = [1, 2, 3]

一些方法和属性�：

count: 数组的长度
isEmpty: 数组是否为空
append: 在数组的尾部添加
removeLast: 移除最后一个元素，注意数组长度不能为空
insert(_ newElement: String, at: Int)：在某个位置插入某个元素
remove(at: Int): 移除某个索引上的元素

#1 构造器创建多个值
# swift中的构造器也可以重载 因此会有很多参数，下面只是其中一个
# 重复3次 2.0 自动推断为 [Double]
var threeDoubles = Array(repeating: 2.0, count: 3)
// [2.0, 2.0, 2.0]

#2 count 表示数组长度
threeDoubles.count // 3

#3 isEmpty 是否是空数组
threeDoubles.isEmpty // false

#4 append 在数组尾部添加,有多个重构 (相当于JS中的push)
threeDoubles.append(3.0) // [2.0, 2.0, 2.0, 3.0]
// threeDoubles.append(contentOf: [3.0])

#5 removeLast 移除数组最后一个元素
# 如果数组不为空，返回被移除得元素
# 如果数组长度为0，使用这个方法会报错
# Can't remove last element from an empty collection
if !threeDoubles.isEmpty {
  threeDoubles.removeLast()
}

#5 insert 在某个位置插入元素
var alphas = ["a", "b", "c"]
alphas.insert("q", at: 1) // ["a", "q", "b", "c"]

#6 remove 移除某个索引位置的元素 返回被移除得元素
alphas.remove(at: 1) // "q"
print(alphas) // ["a", "b", "c"]

两个相同类型的数组使用 + 相加，相当于JS中的 concat,会将2个数组拼接在一起

var a = [1, 2]
var b = [3]
var d = b + a // [3, 1, 2]

使用Range的方式，一次性替换多个元素

var alphas = ["a", "b", "c", "d", "e"]
// 将索引为1，2，3位置的元素替换
alphas[1...3] = ["1", "2"]  // 返回替换的元素 ["1", "2"]
print(alphas) // ["a", "1", "2", "e"]
// 可以看出替换的数量不一定要求相等 可多可少

var betas = ["a", "b", "c", "d", "e"]
// 将索引为1，2，3位置的元素替换
betas[1...3] = ["1", "2", "3", "4"]  // 返回替换的元素 ["1", "2", "3", "4"]
print(alphas) // ["a", "1", "2", "3", "4", "e"]
// 可以看出替换的数量不一定要求相等 可多可少

遍历：

可以使用 arrayInstance.enumerated() 方法获取每项数据的索引和值，这个和JS中的 entities() 方法很像

// 普通遍历
var alphas = ["a", "b", "c"]

for item in alphas {
    print(item)
}
// "a"
// "b"
// "c"

// 使用 enumerated()
for (index, value) in alphas.enumerated() {
  print("item \(String(index + 1): \(value))")
}
// item 1: a
// item 2: b
// item 3: c

2.Set

无序，相同类型，没有重复元素

创建方式：

#1
var letters = Set<Character>()

#2
var letters: Set<Character> = []
letters.insert("a")
letters // {"a"}

#3
var gems: Set<String> = ["diamond", "rock"]
// 根据类型推断 等价于
var gems: Set = ["diamond", "rock"] // {"diamond", "rock"}

一些方法和属性�基本和Array类似，因为是无序集合，Set中没有append方法，还有一些方法也可能不同，这个可以根据编辑器的自动补充功能进行查看，在此略过

遍历Set集合：

普通的 for-in 遍历
对集合使用 sorted() 方法排序之后遍历

var gems: Set = ["diamond", "rock"]
gems.insert("glass")

for gem in gems {
    print(gem)
}
// glass
// rock
// diamond

# 排序之后遍历
for gem in gems.sorted() {
  print(gem)
}
// diamond
// glass
// rock

集合操作

2个集合之间的关系：

intersection(_:): 求2个Sets集合的交集
symmetricDifference(_:): 求2个Sets集合的差集
union(_:): 求2个集合的合集
a.subtracting(b): a - b 之后剩下的元素

var a: Set = [1, 2, 3]
var b: Set<Int> = [2, 3, 4, 5]

# 交集
a.intersection(b)  // {2, 3}

# 差集
a.symmetricDifference(b) // {5, 4, 1}

# 合集
a.union(b) // {4, 2, 3, 1, 5} 因为无序 所以元素是随机排列的

# a - b 之后的集合
a.subtract(b) // {1}

集合成员关系和相等性

2个集合有4种关联：

a.isSubset(of:b): a是否是b的子集
a.isSuperset(of:b): a是否是b的父集合
a.isStrictSubset(of:b) | a.isStrictSuperset(of: b): 判断一个集合是否是另一个集合的子集合或者父集合，并且两个集合并不相等
a.isDisjoint(with: b): 2个集合没有交集

let houseAnimals: Set = ["🐶", "🐱"]
let farmAnimals: Set = ["🐮", "🐔", "🐑", "🐶", "🐱"]
let cityAnimals: Set = ["🐦", "🐭"]

houseAnimals.isSubset(of: farmAnimals)
// true
farmAnimals.isSuperset(of: houseAnimals)
// true
farmAnimals.isDisjoint(with: cityAnimals)
// true

3.Dictionary 字典

这玩意和JS中的对象差不多，但是使用的是中括号。

创建方式：

#1
var names = [Int: String]()

#2 注意创建一个空的字典 [:] 中间有一个冒号
var names: [Int: String] = [:]

#3 类型推断
var names = ["name1": "james", "name2": "kobe"]

#4 创建不同类型的 Any 类型
var names: [String: Any] = ["name": "james", "age": 16]

常用的一些方法属性：

count
isEmpty
updateValue(_:forKey)
removeValue(forKey)

var names = ["name1": "james", "name2": "kobe"]

#1 count
names.count // 2

#2 isEmpty
names.isEmpty // false

#3 添加新的键值对 直接加即可
# 如果该key存在 则更新key所对应的value
# 如果key不存在，则添加新的key-value
names["name3"] = "durant" // "durant"
names // ["name1": "james", "name2": "kobe", "name3": "durant"]
# 更新某个key
names["name3"] = "west" // "west"
names // ["name1": "james", "name2": "kobe", "name3": "west"]

#4 updateValue(_:forKey) 返回的是可选类型
# 注意这个方法和上面直接更新的区别
names.updateValue("harden", forKey: "name2") // 返回先前值 "west"
names // ["name1": "kobe", "name": "james", "age": 16, "name2": "harden"]
// 如果先前没有该key 则生成新的key-value
names.updateValue("jordan", forKey: "name3") // nil 因为先前没有 "name3" 这个key
names // ["name1": "kobe", "name": "james", "age": 16, "name2": "harden", "name3": "jordan"]

#5 removeValue(forKey:) 移除某个key-value 如果不存在该key则返回nil
names.removeValue(forKey: "name3") // "jordan"
names // ["name1": "kobe", "name": "james", "age": 16, "name2": "harden"]

names.removeValue(forKey: "name5") // nil

遍历:

dictInstance.keys: 获取字典的所有keys,注意这不是一个方法
dictInstance.values: 获取字典所有的values

var info: [String: Any] = ["name": "james", "age": 18]

for (key, value) in info {
  print(key, value)
}
// name james
// age 18

for (_, value) in info {
  print(value)
}
// james
// 18

# 使用keys()
for key in info.keys {
  print(key)
}
// name
// age

# 使用value()
for value in info.values {
  print(value)
}
// james
// 18

var ss = [String](info.keys) // ["name", "age"]

全部频道

#4 集合类型

1.Array

2.Set

3.Dictionary 字典