Swift 容器类型总结

1. Swift提供了三种主要的容器类型：数组（Array）、集合（Set）和字典（Dictionary）。
数组存储相同类型的元素，集合存储有序不重复的值，字典采用键值对来存储元素。
数组、集合和字典对于自己存储的值的类型非常清楚，也就是意味着往容器中插入一个不同类型的值，同时也意味着你从容器中取得的元素的类型是确定的。

容器的可变性：当你创建了一个数组、集合或者字典，并且指定它为变量，那么创建出来的容器是可变的，你可以增加、删除元素，也可以改变元素的值。
但是如果你指定它为常量的话，那么该容器是不可变的，即是说其内容和大小均不可改变。

2. 数组：数据是在一个有序表中存储相同类型的值的容器，可以在不同的位置出现相同的值。Array和Foundation库中的NSArray类相关。 

   a.  数组类型的简写：Swift语言数组类型的完整的写法是Array<Type>,其中Type是数组中值的类型。
 你也可以简写为[Type]的形式，尽管两种方式的功能是一样的，但一般提倡用后者。如：

    let arr1: Array<Int> = {1,2,3}
    let arr2:[Int] = {1,2,3}

   b. 创建一个空数组：

    var someInts = [Int]()
    //someInts的类型会被推断了[Int]类型。
    someInts.append(3)
    //someInts现在含有一个元素为3
    someInts = []；
    //someInts现在又为空了，但是其类型仍然为[Int]

   c. 采用默认值的方式创建数组：

    var threeDoubles = [Double](count: 3, repeatedValue: 0.0)
    //threeDoubles的大小为3，元素默认值全部为0.0

   d.  采用合并数组的方式创建数组：

    var anotherThreeDoubles = [Double](count: 3, repeatedValue: 2.5)
    var sixDoubles = threeDoubles + anotherThreeDoubles;
        //现在sixDoubles的值为[0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

  e.  通过数组字面值来创建数组：     
 你可以采用数组字面值来初始化一个数组：
 var shoppingList:[String] = ["Egg", "Milk"]
 由于Swift的类型推断，所以你也可以写成：
 var shoppingList = ["Egg", "Milk"]。

   f. 访问和修改数组：你可以通过数组提供的方法或者元素来修改数组，也可以通过下标来访问和修改数组。
    1) 获取数组的元素的个数：count属性，如：shoppingList.count；
    2) 判断一个数组是否为空：isEmpty属性，如：shoppingList.isEmpty;也可以根据count是否为0来判断；
    3) 添加一个元素：append(_:)方法，如：shoppingList.append("Fruit");
    4) 采用“+”操作符来添加一个或者多个元素：
    shoppingList += ["Fruit"]
    shoppingList += ["Fruit", "Bread"]
    5) 通过下标来访问元素：
    let firstItem = shoppingList[0]
    6) 通过下标来修改元素：
    shoppingList[0] = "Six Eggs"
    你可以一次性修改多个元素，如shoppingList的元素为：
    ["Egg", "Milk", "Fruit", "Bread", "Chocolate Spread", "Cheese", "Buffer"]
    shoppingList[4...6] = ["Banana", "Apple"]
    原数组中要被替换的个数和所给的元素的个数不一样也是没关系的，刚刚的例子就是这样的情况，原来的数组元素有7个，现在变成了6个。
    7) 在指定的位置插入元素：insert(_:atIndex:)方法，如：
    shoppingList.insert("Cookies", atIndex: 3)
    注意，下标不能越界，否则有运行时错误。
    8) 移除指定位置的元素：removeAtIndex(_:)，如：
    shoppingList.removeAtIndex(3)
    注意，下标不能越界，否则有运行时错误。
    9) 移除最后一个元素：let apples = shoppingList.removeLast()

 - 遍历数组：
    1) for-in循环：

    for item in shoppingList{
        print(item)
    }

    2) 枚举：enumerate()

    for (index, item) in shoppingList.enumerate(){
        print("\(index) item is \(item)")
    }

集合：集合是存储相同类型不同值的无序容器，即是说集合中的元素没有相同的，而且是无序的。Set和Foundation库中的NSSet相关。

    a. 集合类型的哈希值（Hash Values）:
    在集合中存储的元素的类型必须有哈希值，即是说这个类型必须提供一个方法来计算本身的哈希值。
    哈希值是一个Int类型的值，所有具有等值哈希值的对象都认为是相同的，即是，a.hashValue == b.hashValue，那么 a == b。
    Swift的所有基本类型(如：String、Int、Double、Bool)默认都是可哈希的，所以可以作为集合元素的类型，也可作为字典键的类型。
    没有关联值的枚举类型默认也是可哈希的。

    b. 集合类型参数：
    Swift的集合类型写成：Set<Type>，不像数组，集合是没有简写的方式的。

    c. 创建和初始化一个空集合：

        var letters = Set<Character>()
        //现在letters是一个空集合，没有元素
        letters.insert("a")
        //现在letters有一个元素"a"
        letters = []
        //现在集合又是一个空的集合

    d. 采用数组字面值来创建集合：
    var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]
    由于Swift的类型推断，所以可以写成：
    var favoriteGenres: Set = ["Rock", "Classical", "Hip hop"]
    但是不能写成：
    var favoriteGenres = ["Rock", "Classical", "Hip hop"]
    这样就成了数组了。

    e. 访问和修改集合：
    1) 获取元素个数和判断是否为空与数组一样；
    2) 插入元素：insert( _: )方法：
    favoriteGenres.insert("Jazz")
    3) 删除元素：remove(_:)方法：
    favoriteGenres.remove("Jazz")
    注意，如果元素存在，remove(_:)方法返回该元素，并在集合中删除该元素，如果集合中不含有该元素，则返回nil。
    4) 包含元素：可以采用contains(_:)方法判断集合是否包含某个元素，返回值为布尔类型。

    f. 遍历集合：
    1）for-in循环
    2）排序完之后循环：

        for item in favoriteGenres.sort(){
            print(item)
        }

    g. 集合操作：a和b是两个集合，它们有如下的操作：
        1) intersect(_:)：a和b交集；
        2) exclusiveOr(_:) ：a和b交集的补集；
        3) union(_:)：a和b的并集；
        4) subtract(_:)：a和b的差集 ；

    h. 判断所属关系：a、b和c是三个集合
        1) == ：判断两个集合是否相等，即是含有相同的元素；
        2) isSubsetOf(_:)：判断是否为子集；
        3）isSupersetOf(_:) ：判断是否为父集。

字典：字典是存储键-值对的元素的无序容器。每一个值都和独一无二的键相关联。Dictionary和Foundation库中的NSDictionary相关。
    a. 字典类型参数简写：
    字典类型参数完整的写法是：Dictionary<Key, Value>,可简写为[Key: Value]如：
    var dic: Dictionary<String,Int>
    var dic1: [String:Int]

    b. 创建一个空字典：
    var dic = [Int: String]()
    //创建了一个空字典
    dic[24] = "ZHUO Zeng-si"
    //字典现在有一个键值对了
    dic = [:]
    //字典现在又为空了

    c. 采用字典字面值来创建字典：
    var airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]
    var airports = ["YYZ": "Toronto Pearson", "DUB": "Dublin"]


    d. 访问和修改字典：
        1) 获取元素个数和判断字典是否为空和数组相同；
        2) 增加元素：
        键值对：airports["LHR"] = "London Heathrow"
        updateValue(_:forKey:)：airports.updateValue("London Heathrow", forKey: "LHR")
        如果键值对在字典中存在，则更新值，若不存在，则添加；
        而且该方法返回一个可选值，若原来有键值对在字典中存在，则返回键值对的值，否则，返回nil。
        3) 通过下标访问字典，返回一个可选值，如：
        if let airport = airports["LHR"] {
            print("\(airport)");
        }else{
            print("there is no value with the key is LHR")
        }
        4) 删除元素：
        将一个元素的值设为nil,则该元素就在字典中删除了，如：
        airports["LHR"] = nil
        也可以采用removeValueForKey(_:) 这个方法来删除一个键值对。
        如果键值对存在，该方法返回值，若键值对不存在，则返回一个nil,如下面的可选绑定：
        if let airport = airports.removeValueForKey("LHR"){
            print("\(airport)");
        }else{
            print("there is no value with the key is LHR")
        }
        5) 遍历字典：
        for - in 循环：
            a) 遍历元素：

            for (airportCode, airportName) in airports {
                    print("\(airportCode) : \(airportName)" )
            }

            b) 遍历键：

                for airportCode in airports.keys {
                    print("Airport Code: \(airportCode)")
                }

            c) 遍历值：

                for airportName in airports.values {
                    print("Airport Name: \(airportName)")
                }

        6）获取字典的所有键和值：

            let airportNames = [String](airports.values)
            let airportCodes = [String](airports.keys)