Swift基础3

集合的可变性

---

如果创建一个数组，集合或者字典并且把它们分配成一个变量，这个集合就将会是可变的。如果我们把它们分配成常量，那么它就是不可变的，它的大小不能被改变。

数组

---

1.数组使用有序列表存储同一类型的多个值。相同的值可以多次出现宰一个数组的不同位置中。
2.Swift中数组的形式：Array,其中Element是这个数组中唯一允许存在的数据类型。我可以使用像[Element]这样的简单语法。

var arr1 = Array()
var arr2 = [Int]()

3.如果代码上下文中已经提供了类型信息，我们可以使用空数组语句创建一个空数组［］（一对空方括号）

var arr = [Int]()
arr.append(3)
arr = []

4.创建一个带有默认值的数组

var arr = [Int](count: 5, repeatedValue: 100)

5.我们可以使用加法操作符（＋）来组合两种已经存在的相同类型数组。新数组的数据类型会被从两个数据类型中推断出来：

var arr1 = [Double](count: 5, repeatedValue: 10.0)
var arr2 = Array(count: 2, repeatedValue: 1.0)
var arr3 = arr1 + arr2  

6.使用字面量构造数组。
我们可以使用字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。字面量是一系列由逗号分割并由方括号包含的数值：

var arr = ["one","two"]

7.访问和修改数组

1).我们可以使用数组的只读属性count来获取数组中的数据项数量：

var arr = ["one","two"]
let count = arr.count

2).使用布尔值属性isEmpty作为检查count属性的值是否为0的捷径：

if arr.isEmpty {
    print("the array is empty")
}else{
    print("the array is not emppty")
}

3).使用append(_:)方法在数组后面添加新的数据项：

var arr = ["one","two"]
arr.append("three")

4).使用加法赋值运算符（+=）也可以直接在数组后面添加一个或多个拥有相同类型的数据项：

var arr = ["one","two"]
arr.append("three")
arr += ["four"]
arr += ["five","six"]

5).我们可以直接使用下标语法来获取数组中的数据项，也可以使用下标来改变某个已有索引值对应的数据值：

var arr = ["one","two"]
var firstItem = arr[0]
arr[0] = "1"
firstItem = arr[0]

6).我们还可以使用下标来一次改变一系列数据值：

var arr = ["one","two","three","four"]
arr[1...3] = ["2","3","4"]
print(arr)

7).我们不能使用下标访问的形式在数组的尾部添加新项。我们调用insert(_:atIndex:) 方法在某个具体索引值之前添加数据项：

var arr = ["one","two","three","four"]
arr.insert("zero", atIndex: 0)

8).我们可以使用removeAtIndex(_:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项。

var arr = ["one","two","three","four"]
arr.removeAtIndex(1)

9)我们也可以使用removeLast()方法删除数组的最后一项。使用removeFirst()方法删除数组第一项。

var arr = ["one","two","three","four"]
arr.removeLast()
arr.removeFirst()
arr

数组遍历

1.我们可以使用for－in循环遍历数组中的所有数据项：

var arr = ["one","two","three","four"]
for item in arr {
    print(item)
}

2.如果我们同时需要每个数据项的值和索引值，那么我们可以使用enumerate()方法来进行数组遍历。enumerate()返回一个由每一个数据项索引值和数据值组成的元组。

var arr = ["one","two","three","four"]

for var (index,value) in arr.enumerate(){
    print("item \(index) is \(value)")
}

集合

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

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

2.Swift的所有基本类型（比如，String，Int，Double和Bool）默认都是可哈希化的，可以作为集合的值的类型或者字典的键的类型。

3.我们可以使用自定义的类型作为集合的值或者是字典的键，但是我们需要我们自定义的类型复合Swift标准库中 Hashable协议。符合Hashable协议的类型需要提供一个类型的Int的可读属性hashValue。由类型的hashValue属性返回的值不需要在同一程序的不同执行周期或者不同程序之间保持相同。

4.因为Hashable协议符合Equatable协议，所以符合该协议的类型也必须提供一个“是否相等”的运算符（==）的实现。这个Equatable协议要求任何符合==实现的实例间都是一种相等的关系。也就是说，对于
a,b,c三个值来说，==的实现必须满足下面三种情况：
＊ a == a (自反性)
＊ a == b 意味着 b == a (对称性)
＊ a == b && b == c 意味着 a == c (传递性)

集合语法

在Swift中的Set类型被写成Set, 这里的Element表示Set中允许存储的类型，和数组不同的是，集合没有等价的简化形式。

1.创建和构造一个空的集合

var set = Set()

2.如果上下文提供了类型信息，我们可以通过一个空的数组字面量创建一个空的Set：

var set = Set()
set.insert("c")
set = []

3.使用数组字面量创建集合
由于Swift的类型推断功能，如果我们使用一个数组字面量构造一个Set并且该数组字面量中的所有元素类型都相同，那么我们就无须写出Set的具体类型。

var set1: Set = ["hello",3]

var set2: Set = ["hello","world"]

4.访问和修改一个集合

1).我们可以使用只读属性count，来获取一个Set的元素数量

2).我们可以使用isEmpty作为缩写形式去检查count属性是否为0

3).我们可以通过Set的insert(_:)方法来添加一个新元素：

var set: Set = ["hello","world"]
set.insert("!")

4).我们可以通过Set的remove(_:)方法去删除一个元素，如果该值是set中的一个元素，则删除该元素并且返回被删除的元素值。否则如果该set不包含该值，则返回nil。另外set中的所有元素可以通过它的removeAll()方法删除

var set: Set = ["hello","world"]

set.remove("hello")

5).使用contains(_:)方法去检查Set中是否包含一个特定的值：

var set: Set = ["hello","world"]

set.contains("hello")
//true

遍历集合

1.我们可以使用for－in遍历Set中的所有元素

var set: Set = ["hello","world","!"]
for item in set {
    print(item)
}

2.Swift的Set集合类型是没有确定顺序的，为了按照特定顺序来遍历一个Set中的所有元素可以使用sort()方法，它将根据提供的序列返回一个有序集合。

var set: Set = ["hello","world","!"]
for item in set.sort() {
print(item)

}

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

var x:Set = [1,2,3,5,7,9]
var y:Set = [2,4,6,8]


let  a = x.intersect(y).sort()
//2

let b = x.exclusiveOr(y).sort()
//1,3,4,6,7,8,9


let c = x.union(y).sort()
//1,2,3,4,5,6,7,8,9

let d = x.subtract(y).sort()
//1,3,5,7,9

集合成员关系和相等

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

var x:Set = [1,2,3,5,7,9]
var y:Set = [1,2,3]

x.isSubsetOf(y)
//false

x.isStrictSubsetOf(y)
//false

x.isSupersetOf(y)
//true

x.isStrictSupersetOf(y)
//true

x.isDisjointWith(y)
//false

字典

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

字典类型的快捷语法

1.Swift的字典使用 Dictionary 定义，其中Key是字典中键的数据类型，Value是字典中对应于这些键所存储的数据类型。

2.note：一个字典的key类型必须遵循Hashable协议，就像Set的值类型。

3.我们也可以用[Key:Value] 这样的快捷方式去创建一个字典类型。

var dic = [Int : String]()
var dic2 = Dictionary()

4.如果根据上下文已经知道字典的类型，那么我们可以使用空字典字面量来创建一个空字典，记作[:].

var dic = [Int : String]()

dic[1] = "hello"

dic = [:]

5.我们可以使用字典字面量来构造字典，字典字面量是一种将一个或多个键值对写作Dictionary集合的快捷途径。

var dic = [1:"一",2:"二",3:"三"]

访问和修改字典

1.我们可以通过字典的只读属性count来获取某个字典的数据项数量；
2.使用布尔属性isEmpty来快捷的检查字典count属性是否等于0；
3.我们可以在字典中使用下标语法来添加新的数据项。可以使用一个恰当的类型的键作为下标索引，并且分配恰当类型的新值：

var dic = [1:"一",2:"二",3:"三"]
dic[4] = "四"
print(dic)
//[2: "二", 3: "三", 1: "一", 4: "四"]

4.字典的updateValue(_:forKey:)方法可以设置或者更新特定键对应的值。就像上面所示的那个下标示例，updateValue(_:forKey:)方法在这个键不存在对应值的时候会设置新值或者在存在时更新已存在的值。和上面的下标方法不同的，updateValue(_:forKey:)这个方法返回更新值之前的原值。这样使得我们可以检查更新是否成功。

5.我们使用下标语法从字典中检索特定键对应的值。因为有可能请求的键没有对应的值存在，字典的下标访问会返回对应值的类型的可选值。

var dic = [1:"一",2:"二",3:"三"]

if let value = dic[2] {
    print("dic[2] value is \(value)")
}else{
    print("dic[2] value is nil")
}

6.我们还可以使用下标语法来通过给某个键对应值赋值为nil来从字典里移除一个键值对；

var dic = [1:"一",2:"二",3:"三"]
dic[2] = nil
print(dic)
//[3: "三", 1: "一"]

7.我们也可以使用 removeValue(_:)方法也可以用来在字典中移除键值对。这个方法在键值对存在的情况下会移除该键值并且返回被移除的值或者在没有值的情况下返回nil；

var dic = [1:"一",2:"二",3:"三"]
if let removedValue = dic.removeValueForKey(2) {
    print("the removed value is \(removedValue)")
}else{
    print("the dic not contain the key and value of 2")
}

字典遍历

1.我们可以使用for－in循环来遍历某个字典中的键值对。每一个字典中的数据项都以（key，value）元组形式返回，并且我们可以使用临时常量或者变量来分解这些元组；

var dic = [1:"一",2:"二",3:"三"]
for var (key,value) in dic {
    print("the key \(key) and value is \(value)")
}

2.通过keys或者values属性，我们也可以遍历字典的键或者值：

var dic = [1:"一",2:"二",3:"三"]
for key in dic.keys {
    print("the key is \(key)")
}

for value in dic.values {
    print("the value is \(value)")
}