Swift語言的集合類型:
1.有序可重復---數組(Array)
2.無序不重復---集合 (Set)
3.無序可重復，但每個值有唯一的鍵(key)---字典 (Dictionary)
批量處理集合中的元素，可以使用for in 循環。
----數組----
1.數組的常用操作
//定義：Array <類型> 或 [類型]
//隱式初始化
var a = ["A","E","I","O","U"]
//顯式初始化
var b : [Int] = [1,2,3,4,5]
var c : Array<Int> = [1,2,3,4,5]
//初始化空數組
var emptyArray1: [Int] = []
var emptyArray2: Array<Int> = []
var emptyArray3 = [Int]()
//注意：聲明的array類型是NSArray
//var array = []
//重復10次，元素是3
let array1 = [Int](repeatElement(3, count: 10))
//創建一個有序范圍的Int數組 Array(起始值...終止值)
let array2 = Array(0...10)
var addressArray = ["北京","上海"]
//對一個數組中添加元素
addressArray.append("武漢")
let otherAddress = ["天津","鄭州"]
//兩個數組合并為一個數組 +=
addressArray = addressArray + otherAddress
//插入xx到第幾個
addressArray.insert("南京", at: 5)
//移除
addressArray.remove(at: 2)
print(addressArray) //["北京", "上海", "天津", "鄭州", "南京"]
//移除全部
addressArray.removeAll()
2.數組的增刪改查
//獲取數組第一個元素和最后一個元素
var addressArray = ["北京", "上海", "天津", "鄭州", "南京","濮陽","深圳"]
addressArray.first
addressArray.last
//判斷數組是否包含某個元素，返回一個布爾量
addressArray.contains("鄭州") //true
//判斷數組是否包含某個元素，同時也知道元素所在索引位置，返回一個Int量，沒有的話返回nil
addressArray.index(of: "鄭州")
//遍歷數組
for index in 0..<addressArray.count {
print(addressArray[index])
}
//方法2，不需要獲取索引
for number in addressArray{
print(addressArray)
}
addressArray.removeSubrange(0...1)
//刪除第一個元素
addressArray.removeFirst()
//刪除最后一個元素
addressArray.removeLast()
//刪除指定一個元素
addressArray.remove(at: 1)
//通過索引獲取到元素直接修改
addressArray[0] = "Object-C"
//通過索引范圍獲取到一個子數組進行修改值
addressArray[0...1] = ["Object-C2","Object-C3"]
----Set----
1. Set的常用操作
//集合需要顯示申明出來
//申明一個空集合
var emptySet1 : Set<Int> = []
var emptySet2 = Set<Double>()
//集合可以去重
var skillOfA : Set<String> = ["OC","Swift","OC"] //{"OC", "Swift"}
var skillOfB : Set = ["H5","CSS","Java"]
//判斷集合是否為空集合
skillOfB.isEmpty //false
emptySet1.isEmpty //true
//集合元素個數
skillOfB.count
//數組強制轉成集合
var a = Set(["A","B","C","D","E","E"])
var A : Set <String> = ["A","B","C","D","E"]
//轉換為數組：sorted
let C = A.sorted()
//判斷某個集合是否包含某個元素，返回一個布爾量
skillOfA.contains("Swift") //true
skillOfB.contains("swift") //false
/****遍歷集合******/
for skill in skillOfB{
print(skill)
}
/****集合比較******/
let A : Set = [1,2,3]
let B : Set = [1,2,3,1,1,2,2,3,3]
A == B //true
增刪
var A : Set <String> = ["A","B","C","D","E"]
//增
A.insert("F")
//刪
A.remove("B")
A.removeAll()
交 補 并 差
//需要一個個測試，如果打開其中一個，請先注釋其他的操作
var x : Set = [1,2,3,4]
var y : Set = [3,4,5,6]
//交集 intersection
x.intersection(y) //3 4
//差集
x.subtract(y) //1 2
//并集
x.union(y) // 5, 6, 2, 3, 1, 4
//補集
x.formSymmetricDifference(y) //5, 6, 2, 1
其他操作
var x : Set = [3,4]
var y : Set = [3,4,5,6]
//子集：isSubset（可以相等） 嚴格子集
x.isSubset(of: y)
x.isStrictSuperset(of: y)
//無交集:isDisjoint
x.isDisjoint(with: y)
----字典----
1.字典的常用操作
//****聲明空字典4種方式****
var emptyDict:[String:Int] = [:]
var emptyDict1:Dictionary<Int,String> = [:]
var emptyDict2 = [String:String]()
var emptyDict4 = Dictionary<Int,Int>()
//隱式初始化
var airports1 = ["PVG":"Shanghai Pudong","CHU":"Dalian"];
//顯式字典key-value類型初始化
var airports2 : [String:String] = ["PVG":"Shanghai Pudong","CHU":"Dalian"];
//顯式字典類型以及key-value類型初始化
var airports3 : Dictionary<String,String> = ["PVG":"Shanghai Pudong","CHU":"Dalian"];
//添加或更新---沒有的key會添加，有的會會更新
airports1["SHQ"] = "Hongqiao Airport"
airports1["CHU"] = "大連周水子機場"
//移除，用下標把值設為nil
airports1["PVG"] = nil
//字典集合個數
airports1.count
//判斷字典是否為空字典
airports1.isEmpty //false
//循環一個字典 for in ，因為鍵值對有2個元素，用元組變量
for (key,value) in airports1 {
print(key,value)
}
//單獨使用其中鍵或值，使用keys或values
for key in airports1.keys {
print(key)
}
//把鍵值對分離成數組，用[數組類型](字典變量.key) [數組類型](字典變量.value)
let codes = [String](airports1.keys)
let airName = [String](airports1.values)
增刪改
var user = ["name":"姓名","password":"密碼"]
//增加或修改
//方法1
user.updateValue("100000@qq.com", forKey: "email")
//方法2
user["email"] = "1111111@qq.com"
//刪除
user["email"] = nil
user.removeValue(forKey: "name")
----下標----
下標是方法的一種，是訪問集合 列表或者序列中的元素的快捷方式。 用法：實例名[索引]。 可以訪問或設置其中元素，下標可以是多維或嵌套的。
//定義形式：一個名為sunscript的計算屬性，可以忽略set（只讀）
/*
subscript(index: 參數類型) -> 返回類型 {
get {}
set {}
}
*/
//常見的用法：字典，數組，集合等
var array = [1,2,3,4,5]
array[0]
var dict = ["a":"1","b":"2","c":"3"]
dict["b"]
//通過下標簡化調用方法調用
struct Cycle {
func area(radius : Double) -> Double {
return Double.pi * pow(radius, 2)
}
subscript(radius :Double) -> Double {
return Double.pi * pow(radius, 2)
}
}
let cycle = Cycle()
cycle.area(radius: 3)
cycle[3]
