Swift语法_集合类型(Array.Set. Dictionary)

一：概念
Swift 语言提供 Arrays 、 Sets 和 Dictionaries 三种基本的集合类型用来存储集合数据。

1. 数组(Arrays)是有序 数据的集。
2. 集合(Sets)是无序无重复数据的集。
3. 字典(Dictionaries)是无序的键值对的集。

Swift 的 Arrays 、 Sets 和 Dictionaries 类型被实现为泛型集合。更多关于泛型类型和集合

二：集合的可变性
如果创建一个 Arrays 、 Sets 或 Dictionaries 并且把它分配成一个变量,这个集合将会是可变的。
如果我们把 Arrays 、 Sets 或Dictionaries分配成常量,那么它就是不可变的,它的大小不能被改变。（好习惯：不需要改变集合大小的时候创建不可变集合）

---

三：数组

• 有序

概念：数组使用有序列表存储同一类型的多个值。相同的值可以多次出现在一个数组的不同位置中。

数组的简单语法

写 Swift 数组应该遵循像 Array<Element> 这样的形式,其中 Element 是这个数组中唯一允许存在的数据类 型。我们也可以使用像 [Element] 这样的简单语法。尽管两种形式在功能上是一样的,但是推荐较短的那种,而 且在本文中都会使用这种形式来使用数组。

创建数组：

/*  创建数组**/
//1:创建一个空数组
//(1)通过构造函数的类型, someInts 的值类型被推断为 [Int]
var someInts1 = [Int]()//[]
//(2)使用空数组语句创建一个空数组,它的写法很简单: []
var someInts2 = []//()仍然是 [Int] 类型的

//2:创建一个带有默认值的数组
var threeDoubles = [Double](count: 3, repeatedValue: 1.2)
var threeDoubles2 = [Double](count: 3, repeatedValue: 0.9)
var sixDouble = threeDoubles + threeDoubles2

///3:字面量构造数组
var foodList = ["Egg","Milk"]

数组的访问和修改

/*  访问和修改数组**/
//1:只读属性count访问数组个数
foodList.count

//2:布尔值属性 isEmpty 作为检查数组是否为空（count＝=0）
if foodList.isEmpty{

}
//3: append(_:) 方法在数组后面添加新的数据项
foodList.append("orange")

//4:加法赋值运算符( += )也可以直接在数组后面添加一个或多个拥有相同类型的数据项
foodList += ["Chocolate Spread", "Cheese", "Butter"]

//5:访问数组下标对应元素
var firstItem = foodList[0]

//6:修改数组某个数据
foodList[1] = "my Milk"

//7:修改数组多条数据
foodList.count //判断下范围，避免下行代码越界
foodList[4...5]=["Bananas","Apples","abc","egg"]

//8:修改数组元素
foodList.insert("pear", atIndex: 0)
foodList.removeAtIndex(0)
foodList.removeFirst()
foodList.removeFirst(2)
foodList.removeLast()
foodList.count
let range = foodList.startIndex.advancedBy(0)..<foodList.endIndex
foodList.removeRange(range)
foodList.count
foodList.removeAll()

数组遍历

/**数组的遍历*/
//1:直接遍历
for item in foodList{
print(item)
}
//2:带索引值遍历
for(index,value)in foodList.enumerate(){
print("索引 \(String(index+1)):\(value) ")
}

---

四：集合

• 无序不重复

概念：集合(Set)用来存储相同类型并且没有确定顺序的值。当集合元素顺序不重要时或者希望确保每个元素只出现一次 时可以使用集合而不是数组

集合类型的哈希值 :

一个类型为了存储在集合中,该类型必须是可哈希化的–也就是说,该类型必须提供一个方法来计算它的哈希 值。一个哈希值是 Int 类型的,相等的对象哈希值必须相同,比如 a==b ,因此必须 a.hashValue == b.hashValu e。

Swift 的所有基本类型(比如 String , Int , Double 和 Bool )默认都是可哈希化的,可以作为集合的值的类型或 者字典的键的类型。没有关联值的枚举成员值(在枚举有讲述)默认也是可哈希化的。

注意: 你可以使用你自定义的类型作为集合的值的类型或者是字典的键的类型,但你需要使你的自定义类型符合 Swift 标准库中的 Hashable 协议。符合 Hashable 协议的类型需要提供一个类型为 Int 的可读属性 hashValue 。由类 型的 hashValue 属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。因为 Hashable 协议符合 Equatable 协议,所以符合该协议的类型也必须提供一个”是否相等”运算符( == )的实 现。这个 Equatable 协议要求任何符合 == 实现的实例间都是一种相等的关系。也就是说,对于 a,b,c 三个值来 说, == 的实现必须满足下面三种情况:
• a == a (自反性)
• a == b 意味着 b == a (对称性)
• a == b && b == c 意味着 a == c (传递性)

创建集合

/*创建集合{}**/
//1:创建空集合(没有简方法)
var letters = Set<Character>()//[]

//2:通过数组方式修改成空集合
letters.insert("q")
letters = []

//3:用数组字面量创建集合
var mySet:Set<String> = ["apple","pear","banana","app"]
let mySet1:Set<Int> = [1,2,3]
let mySet2:Set = [1.3,3.2,4.3,5.6]//Set类型必须显式声明,否则是数组

访问和修改一个集合

/**访问和修改一个集合**/
//1:只读属性count访问
mySet.count
//2:布尔属性 isEmpty
if mySet.isEmpty{

}
//3:添加新元素
mySet.insert("cocoa")
//4:删除元素
mySet.remove("coffe")//删除不存在的元素，返回nil，而不是崩溃
//5:包含特定值
mySet.contains("cocoa")

遍历集合

/**遍历一个集合**/
//1:直接遍历（无序）
for item in mySet{
print(item)
}
//2:排序遍历(按字母顺序)
for item in mySet.sort(){
print(item)
}

集合操作 （交／并／补）
你可以高效地完成 Set 的一些基本操作,比如把两个集合组合到一起,判断两个集合共有元素,或者判断两个集 合是否全包含,部分包含或者不相交。

1. 使用 intersect(_:) 方法根据两个集合中都包含的值创建的一个新的集合。
2. 使用 exclusiveOr(_:) 方法根据在一个集合中但不在两个集合中的值创建一个新的集合。
3. 使用 union(_:) 方法根据两个集合的值创建一个新的集合。
4. 使用 subtract(_:) 方法根据不在该集合中的值创建一个新的集合。

/**集合操作 **/
let oddDigits:Set = [1,3,5,7,9]
let evenDigits:Set = [0,2,4,6,8]
let singleDigit:Set = [2,3,5,7]

//交
oddDigits.intersect(evenDigits).sort()
//并
oddDigits.union(evenDigits).sort()
//只在一个中，而不在俩个中
oddDigits.exclusiveOr(evenDigits).sort()
//完全不在后者中
oddDigits.subtract(evenDigits).sort()

集合成员关系和相等

1. 使用“是否相等”运算符( == )来判断两个集合是否包含全部相同的值。
2. 使用 isSubsetOf(_:) 方法来判断一个集合中的值是否也被包含在另外一个集合中。
3. 使用 isSupersetOf(_:) 方法来判断一个集合中包含另一个集合中所有的值。
4. 使用 isStrictSubsetOf(:) 或者 isStrictSupersetOf(:) 方法来判断一个集合是否是另外一个集合的子集合 或者父集合并且两个集合并不相等。
5. 使用 isDisjointWith(_:) 方法来判断两个集合是否不含有相同的值。

/**集合间的关系**/
let me:Set = ["wo"]
let brother:Set = ["ni"]
let father:Set = ["ni","wo","ta"]

//判断两个集合是否包含全部相同的值
me == brother
//判断一个集合中的值是否也被包含在另外一个集合中
me.isSubsetOf(father)
father.isSupersetOf(brother)
//判断一个集合是否是另外一个集合的子集合 或者父集合并且两个集合并不相等。
me.isStrictSubsetOf(father)
father.isStrictSupersetOf(brother)
//判断两个集合是否不含有相同的值。
me.isDisjointWith(brother)

---

五：字典

• 无序
• 键值对

概念：字典是一种存储多个相同类型的值的容器。每个值(value)都关联唯一的键(key),键作为字典中的这个值数 据的标识符。和数组中的数据项不同,字典中的数据项并没有具体顺序。我们在需要通过标识符(键)访问数据 的时候使用字典,这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

Swift 的字典类型是无序集合类型。为了以特定的顺序遍历字典的键或值,可以对字典的keys  或 values 属性使 用  sort()方法。

字典的创建

/** 字典的创建 **/

//简洁语法
//[key:value]

//1:创建一个空字典
var names = [Int:String]()//[:]
names[16] = "sixteen"//赋值
names = [:]//已知类型，可清空字典

//2:用字典字面量创建字典
//简短方式
var airPorts = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
//常规方式
var airPorts1:Dictionary = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
var airPorts2:[ String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]

字典的访问和修改

/**访问和修改字典*/
//1:只读属性count
airPorts.count
//2:布尔属性 isEmpty 
if airPorts.isEmpty{

}
//3:以键值对形式添加字典元素
airPorts["LHR"] = "London"

//4:按键修改值
airPorts["LHR"] = "London Heathrow"

//5:updateValue(_:forKey:) 这个方法返回更新值之前的原值(旧值)
//我们可以根据这个条件来判断 是否更新成功
if let oldAirPort = airPorts.updateValue("AAA", forKey:"LHR"){
    print(oldAirPort)
    print(airPorts["LHR"])//现在是AAA而且可选
}

//如果有值存在于更新前,则这个可选值包含了旧值,否则它将会是 nil 。
if let oldAirPort2 = airPorts.updateValue("", forKey:"LM"){
    print(oldAirPort2)
    print(airPorts["LM"])
}

//6:移除键值对
//通过给某个键的对应值赋值为 nil 
airPorts["LM"]=nil
print(airPorts)

//通过移除某个键
airPorts.removeValueForKey("LHR")
print(airPorts)

//airPorts.removeAll()

字典的遍历

/**字典遍历*/
//通用
for (code,name)in airPorts{
print("机场简写：\(code):机场名字：\(name)")
}

//访问keys或者value属性
for airPortCode in airPorts.keys{
print(airPortCode)
}

for airPortName in airPorts.values{
print(airPortName)
}

字典向数组的转化

/**字典的键值向数组的转化*/
let airportCodes = [String](airPorts.keys)
let airportValues = [String](airPorts.values)