Swift Learning (6) - Collection Types (Fully Ver.)

var initArray: Array<String> = Array<String>()
initArray.append("hello")
print("类型Array<String>的数组为：\(initArray)")
---
output: 类型Array<String>的数组为：["hello"]

var someInts: [Int] = []
print("someInts is of type [Int] with \(someInts.count) items.")  // 打印“someInts is of type [Int] with 0 items.”
---
output: someInts is of type [Int] with 0 items.

someInts.append(3)
print("现在的someInts是：\(someInts)。")
someInts = []
print("someInts现在是\(someInts)，但是依然是[Int]类型的。")
---
output: 现在的someInts是：[3]。
someInts现在是[]，但是依然是[Int]类型的。

var threeDoubles = Array(repeating: 0.0, count: 3)  // threeDoubles是一种[Double]数组，等价于[0.0, 0.0, 0.0]
print("threeDoubles is \(threeDoubles)")
---
output: threeDoubles is [0.0, 0.0, 0.0]

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)  // anotherThreeDoubles被推断为[Double]，等价于[2.5, 2.5, 2.5]
var sixDoubles = threeDoubles + anotherThreeDoubles  // sixDoubles被推断为[Double]，等价于[0.0, 0.0, 0.0, 2.5, 2.5, 2.5]
print("sixDoubles的值为：\(sixDoubles)")
---
output: sixDoubles的值为：[0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

var shoppingList: [String] = ["Eggs", "Milk"]  // shoppingList已经被构造且拥有两个初始项
print("shoppingList is \(shoppingList)")
---
output: shoppingList is ["Eggs", "Milk"]

var shoppingLists = ["Eggs", "Milk"]

print("The shopping list contains \(shoppingLists.count) items.")
---
output: The shopping list contains 2 items.

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}
// 打印“The shopping list is not empty.”（shoppinglist不是空的）
---
output: The shopping list is not empty.

shoppingList.append("Flour")  // shoppingList现在有3个数据项，似乎有人在摊煎饼
print("添加‘Flour’选项后的shoppingList值为：\(shoppingList)。")
---
output: 添加‘Flour’选项后的shoppingList值为：["Eggs", "Milk", "Flour"]。

shoppingList += ["Baking Powder"]  // shoppingList现在有四项了
shoppingList += ["Chocolate Spread", "Chinese", "Butter"]  // shoppingList现在有七项了

var firstItem = shoppingList[0]
print("shoppingList的第一项是：\(firstItem)。")
---
output: shoppingList的第一项是：Eggs。

shoppingList[0] = "Six Eggs"  // 现在shoppingList的第一项是“Six Eggs”而不是“Eggs”
print("修改后的shoppingList值为：\(shoppingList)")
---
output: 修改后的shoppingList值为：["Six Eggs", "Milk", "Flour", "Baking Powder", "Chocolate Spread", "Chinese", "Butter"]

shoppingList[4...6] = ["Bananas", "Apples"]  // shoppingList现在有6项
print("shoppingList现在是：\(shoppingList)")
// 通过调用数组的`insert(_:at:)`方法在某个指定索引值前面添加数据项：
shoppingList.insert("Maple Syrup", at: 0)  // shoppingList现在有7项
// 现在是这个列表中的第一项是“Maple Syrup”
print("shopingList现在的第一项是：\(shoppingList[0])")
// 这次`insert(_:at:)`方法调用把值为"Maple Syrup"的新数据项插入列表的最开始位置，并且使用`0`作为索引值。
---
output: shoppingList现在是：["Six Eggs", "Milk", "Flour", "Baking Powder", "Bananas", "Apples"]
shopingList现在的第一项是：Maple Syrup

let mapleSyrup = shoppingList.remove(at: 0)  // 现在shoppingList只有6项，不包括“Maple Syrup”，常量mapleSyrup等于“Maple Syrup”
print("mapleSyrup的值等于：\(mapleSyrup)，shoppingList等于：\(shoppingList).")
---
output: mapleSyrup的值等于：Maple Syrup，shoppingList等于：["Six Eggs", "Milk", "Flour", "Baking Powder", "Bananas", "Apples"].

firstItem = shoppingList[0]  // firstItem现在等于"Six eggs"
print("此时shoppingList首位是：\(firstItem)")
// 如果只想把数组中的最后一项移除，可以使用`removeList()`方法而不是`remove(at:)`方法来避免需要获取数组的`count`属性。就像后者一样，前者也会返回被移除的数据项。
let apples = shoppingList.removeLast()  // 数组的最后一项被移除了，shoppingList现在只有5项，不包括“Apples”，常量apples现在等于字符串“Apples”
print("常量apples现在的值：\(apples)，shoppingList等于：\(shoppingList).")
// 同样地还有`removeFirst()`方法，直接移除数组的第一项。
let sixEggs = shoppingList.removeFirst()
---
output: 此时shoppingList首位是：Six Eggs
常量apples现在的值：Apples，shoppingList等于：["Six Eggs", "Milk", "Flour", "Baking Powder", "Bananas"].

for item in shoppingList {
    print(item)  // Six eggs; Milk; Flour; Baking Powder; Bananas
}
---
output: Milk
Flour
Baking Powder
Bananas

for (index, value) in shoppingList.enumerated() {
    print("Item \(String(index + 1)): \(value)")  // Item 1: Milk; Item 2: Flour; Item 3: Baking Powder; Item 4: Bananas
}
---
output: Item 1: Milk
Item 2: Flour
Item 3: Baking Powder
Item 4: Bananas

var letters = Set<Character>()
print("Letters is of type Set<Character> with \(letters.count) items.")  // 打印输出“Letters is of type Set<Character> with 0 items.”
---
output: Letters is of type Set<Character> with 0 items.

letters.insert("A")  // letters现在含有1个Character类型的值
print("现在Letters值为：\(letters)")
letters = []  // letters现在是一个空的Set，但是它依然是Set<Character>类型
print("此时Letters值为：\(letters)")
---
output: 现在Letters值为：["A"]
此时Letters值为：[]

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

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

print("I have \(FavoriteGenres.count) favorite music genres.")  // 打印“I have 3 favorite music genres.”
---
output: I have 3 favorite music genres.

if FavoriteGenres.isEmpty {
    print("As far as music goes, I'm not picky.")
} else {
    print("I have particular music preferences.")
}  // 打印“I have particular music preferences.”
---
output: I have particular music preferences.

FavoriteGenres.insert("Jazz")  // FavoriteGenres现在包含4个元素。
print("FavoriteGenres现在包含\(FavoriteGenres.count)个元素，其值为：\(FavoriteGenres)")
---
output: FavoriteGenres现在包含4个元素，其值为：["Classical", "Jazz", "Hip hop", "Rock"]

if let removeGenre = FavoriteGenres.remove("Rock") {
    print("\(removeGenre)? I'm over it!")
} else {
    print("I never much cared of that!")
}  // 打印“Rock? I'm over it!”
---
output: Rock? I'm over it!

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."
---
output: It's too funky in here.

for genre in FavoriteGenres {
    print("\(genre)")
}  // Hip hop; // Classical; // Jazz  无序排列
---
output: Classical
Jazz
Hip hop

for genre in FavoriteGenres.sorted() {
    print("\(genre)")
}  // Classical; // Hip hop; // Jazz  有序排列
---
output: Classical
Hip hop
Jazz

let oddDigits: Set = [1, 3, 5, 7, 9]
let evenDigits: Set = [0, 2, 4, 6, 8]
let singleDigitPrimeNumbers: Set = [2, 3, 5, 7]

print("Union: \(oddDigits.union(evenDigits).sorted())")  // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print("InterSection: \(oddDigits.intersection(evenDigits).sorted())")  // []
print("SubTracting: \(oddDigits.subtracting(singleDigitPrimeNumbers).sorted())")  // [1, 9]
print("SymmetricDifference: \(oddDigits.symmetricDifference(singleDigitPrimeNumbers).sorted())")  // [1, 2, 9]
---
output: Union: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
InterSection: []
SubTracting: [1, 9]
SymmetricDifference: [1, 2, 9]

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

print("IsSubset? \(houseAnimals.isSubset(of: farmAnimals))")  // 打印输出"IsSubset? true"
print("IsSuperset? \(farmAnimals.isSuperset(of: houseAnimals))")  // 打印输出"IsSuperset? true"
print("IsDisjoint? \(farmAnimals.isDisjoint(with: cityAnimals))")  // 打印输出"IsDisjoint? true"
---
output: IsSubset? true
IsSuperset? true
IsDisjoint? true

var namesOfInteger: Dictionary<Int, String> = Dictionary<Int, String>()  // 使用Dictionary<Key, Value>定义字典
print("使用Dictionary<Key, Value>定义字典：\(namesOfInteger)")
var namesOfIntegers: [Int: String] = [:]  // 简化语法，首选！
print("简化语法，首选：\(namesOfIntegers)")
---
output: 使用Dictionary<Key, Value>定义字典：[:]
简化语法，首选：[:]

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

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

var airposts: [String: String] = ["HFE": "Hefei Xinqiao", "NKG": "Nanjing Lukou", "PKX":"Beijing Daxing", "SHA":"Shanghao Hongqiao"]
print("China Main Airpots: \(airposts)")
---
output: China Main Airpots: ["HFE": "Hefei Xinqiao", "NKG": "Nanjing Lukou", "PKX": "Beijing Daxing", "SHA": "Shanghao Hongqiao"]

var chinaAirports = ["HFE": "Hefei Luogang", "NKG": "Nanjing Lukou", "PKX":"Beijing Daxing", "SHA":"Shanghao Hongqiao"]

print("The dictionary of chinaAirports contains \(chinaAirports.count) items.")  // 打印"The dictionary of chinaAirports contains 4 items."
---
output: The dictionary of chinaAirports contains 4 items.

if chinaAirports.isEmpty {
    print("The chinaAirports dictionary is empty.")
} else {
    print("The chinaAirports dictionary is not empty.")
}  // 打印"The chinaAirports dictionary is not empty."
---
output: The chinaAirports dictionary is not empty.

airposts["XIY"] = "Xi'an"  // airports字典现在有五个数据项
print(airposts)
---
output: ["HFE": "Hefei Xinqiao", "NKG": "Nanjing Lukou", "PKX": "Beijing Daxing", "XIY": "Xi\'an", "SHA": "Shanghao Hongqiao"]

airposts["XIY"] = "Xi'an Xianyang"  // "XIY"对应的值被修改为"Xi'an Xianyang"
print(airposts)
---
output: ["HFE": "Hefei Xinqiao", "NKG": "Nanjing Lukou", "PKX": "Beijing Daxing", "XIY": "Xi\'an Xianyang", "SHA": "Shanghao Hongqiao"]

if let oldValue = airposts.updateValue("Hefei Xinqiao", forKey: "HFE") {
    print("The old value for HFE was \(oldValue).")
}  // 打印输出"The old value for HFE was Hefei Xinqiao."
---
output: The old value for HFE was Hefei Xinqiao.

if let airportName = airposts["HFE"] {
    print("The name of the airport is \(airportName).")
} else {
    print("That airport is not in the airports dictionary.")
}  // 打印"The name of the airport is Hefei Xinqiao."
---
output: The name of the airport is Hefei Xinqiao.

airposts["CAN"] = "Guangzhou Baoan"  // Baoan机场是深圳的，所以删除它
print(airposts)
airposts["CAN"] = nil  // CAN现在被移除了
print(airposts)
---
output: ["HFE": "Hefei Xinqiao", "NKG": "Nanjing Lukou", "PKX": "Beijing Daxing", "XIY": "Xi\'an Xianyang", "CAN": "Guangzhou Baoan", "SHA": "Shanghao Hongqiao"]
["HFE": "Hefei Xinqiao", "NKG": "Nanjing Lukou", "PKX": "Beijing Daxing", "XIY": "Xi\'an Xianyang", "SHA": "Shanghao Hongqiao"]

if let removeValue = airposts.removeValue(forKey: "NKG") {
    print("The removed airport's name is \(removeValue).")
} else {
    print("The airports dictionary does not contain a value for NKG.")
}  // 打印"The removed airport's name is Nanjing Lukou."
---
output: The removed airport's name is Nanjing Lukou.

for (airportCode, airportName) in airposts {
    print("\(airportCode): \(airportName)")
}  // HFE: Hefei Xinqiao; // PKX: Beijing Daxing; //SHA: Shanghao Hongqiao; // XIY: Xi'an Xianyang
---
output: HFE: Hefei Xinqiao
PKX: Beijing Daxing
XIY: Xi'an Xianyang
SHA: Shanghao Hongqiao

for airportCode in airposts.keys {
    print("Airport code: \(airportCode)")
}

for airportName in airposts.values {
    print("Airport name: \(airportName)")
}
---
output: Airport code: HFE
Airport code: PKX
Airport code: XIY
Airport code: SHA
Airport name: Hefei Xinqiao
Airport name: Beijing Daxing
Airport name: Xi'an Xianyang
Airport name: Shanghao Hongqiao

let airportCodes = [String](airposts.keys)  // airportCodes是["HFE", "PKX", "SHA", "XIY"]
print(airportCodes)
let airportNames = [String](airposts.values)  // airportNames是["Hefei Xinqiao", "Beijing Daxing", "Shanghai Hongqiao", "Xi'an Xianyang"]
print(airportNames)
---
output: ["HFE", "PKX", "XIY", "SHA"]
["Hefei Xinqiao", "Beijing Daxing", "Xi\'an Xianyang", "Shanghao Hongqiao"]