数组初始化
可以隐式初始化，也可以隐式初始化
<pre>
`
//隐式初始化
var vowels = ["A","E","I","O","U"]
//显式初始化
var numbers:[Int] = [0,1,2,3,4,5]
var numbers1:Array<Int> = [0,1,2,3,4,5]
//申明空数组
var emptyArray1: [Int] = []
var emptyArray2: Array<Int> = []
var emptyArray3 = Int
//申明特定数组个数，并赋同一个初值
var allZeros = [Int](count: 5 , repeatedValue:0)
注意：
var array = []//声明的array类型是NSArray
`
</pre>
数组的基本用法
<pre>
`
//定义3个数组（整型数组，字符串数组，空数组）
var numbers = [1,2,3,4,5]
var vowels = ["A","B","C","D","E"]
var emptyArray = Int
//获取数组个数
vowels.count
//判断空数组
numbers.isEmpty //返回false
emptyArray.isEmpty //返回true
//通过索引来获取数组元素
vowels[0] //A
//获取数组第一个元素和最后一个元素
vowels.first //A
vowels.last //E
emptyArray.first //nil 如果是空数组，通过这种方法获取元素，返回nil
注意：既然能返回nil，说明通过这种方法返回的是个可选型，为此不能直接使用，必须要进行解包
if let firestVowel = vowels.first{
print("The first vowel is " + firestVowel)
}
//获取数组最小值的元素
vowels.minElement() //A
numbers.minElement() //1
//获取元素最大值的元素
vowels.maxElement() //E
numbers.maxElement() //5
//通过范围获取一个子数组
numbers[2..<4] //[3,4]
numbers[2..<numbers.count] //[3,4,5]
//判断数组是否包含某个元素，返回一个布尔量
vowels.contains("A") //true
vowels.contains("P") //false
//判断数组是否包含某个元素，同时也知道元素所在索引位置，返回一个Int量，没有的话返回nil
vowels.indexOf("A") //1
vowels.indexOf("P") //nil
**********遍历数组**********
//方法1
for index in 0..<numbers.count{
numbers[index]
}
//方法2，不需要获取索引
for number in numbers{
print(numbers)
}
//方法3，通过元组进行遍历，可以获取元素和索引
for (index , vowel) in vowels.enumerate(){
print("(index+1):(vowel)")
}
***********数组比较************
var oneToFive = [1,2,3,4,5]
numbers == oneToFive //返回一个true
oneToFive = [2,1,3,4,5]
numbers == oneToFive //返回一个false
//数组是有序的
`
</pre>
数组的更多操作
-
增
<pre>
var courese = ["swift" , "swift2" , "swift3"];
<p>//增加一个数组元素 courese.append("swift4") 等同于.. courese += ("swift5")
<p>//在数组中间插入元素 courese.insert("swift6", atIndex: 2)//注：atIndex参数必须要在数组索引中
</pre>
-
删
<pre>
var courese = ["swift" , "swift2" , "swift3"];
<p>//删除最后一个元素 courese.removeLast()
<p>//删除第一个元素 courese.removeFirst()
<p>//删除指定一个元素 courese.removeAtIndex(2)
<p>//删除一个范围元素 courese.removeRange(0..<2)
<p>删除所有元素 courese.removeAll()
</pre>
-
修改
<pre>
var courese = ["swift" , "swift2" , "swift3"];
<p>//通过索引获取到元素直接修改 courese[0] = "Object-C"
<p>//通过索引范围获取到一个子数组进行修改值 courese[1..2] = ["Object-C2","Object-C3"]
<p>//通过索引范围获取到的一个子数组，被赋值为一个元素的数组，那么相应了，就从有3个元素的数组变成1个元素的数组，对于的courese数组就变成2个元素数组了 courese[0..<4] = ["swift"]//数组只剩下一个元素
</pre>
字典初始化
<pre>
`
//隐式初始化
var dict = ["swift":"雨燕；快速" , "python":"大蟒" , "java":"爪洼岛（位于印尼）" , "groovy":"绝妙的，时髦的"]
//显式字典key-value类型初始化
var dict1: [String:String] = ["swift":"雨燕；快速" , "python":"大蟒" , "java":"爪洼岛（位于印尼）" , "groovy":"绝妙的，时髦的"]
//显式字典类型以及key-value类型初始化
var dict2:Dictionary<String,String> = ["swift":"雨燕；快速" , "python":"大蟒" , "java":"爪洼岛（位于印尼）" , "groovy":"绝妙的，时髦的"]
****声明空字典4种方式****
var emptyDict:[String:Int] = [:]
var emptyDict1:Dictionary<Int,String> = [:]
var emptyDict2 = String:String
var emptyDict4 = Dictionary<Int,Int>()
//通过key取出value
dict["swift"] //取出来的是可选型，必须要进行解包
if let value = dict["swift"]{//解包
print(value)
}
//字典集合个数
dict.count
//判断字典是否为空字典
dict.isEmpty //false
emptyDict.isEmpty //true
//取出字典所有的key和value
dict.keys
dict.values
******遍历字典*******
//遍历key
for key in dict.keys{
print(key)
}
//遍历value
for value in dict.values{
print(value)
}
//遍历字典（利用元组）
for (key,value) in dict{
print("(key):(value)")
}
******字典对比********
let dic1 = [1:"A" , 2:"B"]
let dic2 = [1:"A" , 2:"B"]
let dic3 = [2:"B" , 1:"A"]
dic1 == dic2 //true
dic1 == dic3 //true
结论：字典是无序的。
`
</pre>
字典的操作
-
增
<pre>
只需要传入一个字典没有的key并赋值个value
<p>var user = ["name":"bobobo","password":"liuyubo","occupation":"programmer"]
<p>//方法1 user.updateValue("4399.com", forKey: "website")
<p>//方法2 user["email"] = "524297115@qq.com"
</pre>
-
修改
<pre>
只需要通过key获取到value，修改即可。
<p>var user = ["name":"bobobo","password":"liuyubo","occupation":"programmer"]
<p>//方法1 user["occupation"] = "freelancer"
<p>//方法2 user.updateValue("imooc", forKey: "password")
</pre>
-
删除
<pre>
<p>//方法1 user["website"] = nil
<p>//方法2 user.removeValueForKey("website")//返回的是可选型 if let website = user.removeValueForKey("email"){ print("\(website)删除成功") }
<p>//删除所有元素 user.removeAll()
</pre>
集合初始化
<pre>
`
集合需要显示申明出来
//集合可以去重
var skillOfA:Set<String> = ["swift","OC","OC"]
//申明一个空集合
var emptySet1:Set<Int> = []
var emptySet2 = Set<Double>()
//数组强制转成集合
var vowels = Set(["A","E","I","O","U","U"])
var skillOfB: Set = ["HTML","CSS","Java"]
//集合元素个数
skillOfB.count
//判断集合是否为空集合
skillOfB.isEmpty //false
emptySet1.isEmpty //true
//因为集合是无须的，所以这里的first看作随机取出集合的一个元素
let e = skillOfA.first
//判断某个集合是否包含某个元素，返回一个布尔量
skillOfA.contains("swift") //true
skillOfB.contains("swift") //false
****遍历集合******
for skill in skillOfB{
print(skill)
}
****集合比较******
let setA: Set = [1,2,3]
let setB: Set = [1,2,3]
let setC: Set = [3,2,1]
let setD: Set = [1,2,3,1,1,1,1,2,2,3,3]
setA == setB //true
setA == setC //true
setA == setD //true
结论：集合是无序、去重的
`
</pre>
集合的操作
<pre>
`
//初始化6个集合
var skillsOfA: Set<String> = ["swift","OC"]
var skillsOfB: Set<String> = ["HTML","CSS","Javascript"]
var skillsOfC: Set<String> = []
var skillsOfAA: Set<String> = ["swift","OC"]
var skillsOfBB: Set<String> = ["HTML","CSS","Javascript"]
var skillsOfCC: Set<String> = ["swift","HTML","CSS"]
`
</pre>
-
增
<pre>
skillsOfC.insert("swift") skillsOfC.insert("HTML") skillsOfC.insert("CSS") //注：如果再添加相同的元素，没有任何意义
</pre>
-
删
<pre>
skillsOfC.remove("CSS") skillsOfC skillsOfC.removeAll()
</pre>
-
并集
<pre>
union //不改变调用者集合元素 unionInPlace //改变调用者集合元素
<p>skillsOfAA.union(skillsOfCC) //输出"swift,CSS,OC,HTML" skillsOfAA //没有变化
<p>skillsOfAA.unionInPlace(skillsOfCC) //输出"swift,CSS,OC,HTML" skillsOfAA //输出"swift,CSS,OC,HTML"
</pre>
-
交集
<pre>
intersect //不改变调用者集合元素 intersectInPlace //改变调用者集合元素
<p>skillsOfAA.intersect(skillsOfCC) //输出"swift" skillsOfAA //没有变化
<p>skillsOfAA.intersectInPlace(skillsOfCC) //输出"swift" skillsOfAA //输出"swift"
</pre>
-
减法
<pre>
subtract //不改变调用者集合元素 subtractInPlace //改变调用者集合元素
<p>skillsOfAA.subtract(skillsOfCC) //输出"OC" skillsOfAA //没有变化
<p>skillsOfAA.subtractInPlace(skillsOfCC) //输出"OC" skillsOfAA //输出"OC"
</pre>
-
亦或
<pre>
exclusiveOr //不改变调用者集合元素 exclusiveOrInPlace //改变调用者集合元素
<p>skillsOfAA.exclusiveOr(skillsOfCC) //输出"OC,HTML,CSS" skillsOfAA //没有变化
<p>skillsOfAA.exclusiveOrInPlace(skillsOfCC) //输出"OC,HTML,CSS" skillsOfAA //输出"OC,HTML,CSS"
</pre>
-
其他操作
<pre>
var skillsOfD: Set = ["swift"]
<p>//子集、真子集 skillsOfD.isSubsetOf(skillsOfAA) //true skillsOfD.isStrictSubsetOf(skillsOfAA) //true
<p>//超集、真超集 skillsOfAA.isSupersetOf(skillsOfD) //true skillsOfAA.isStrictSupersetOf(skillsOfD) //true
<p>//判断2个集合是否相离，没有公共元素 skillsOfAA.isDisjointWith(skillsOfBB) //true skillsOfAA.isDisjointWith(skillsOfCC) //false
</pre>
