swift編程語言中有三種常用的收集類型，分別為：數(shù)組Array, 集合Set和字典Dictionary。這三種類型都屬于結(jié)構(gòu)體類型，都是以泛型的形勢定義的，以var聲明一個收集類型的變量對象，那么該對象是以可修改的方式創(chuàng)建的，可以對該對象做添加，修改，刪除等操作；以let聲明的對象，不能改變它的值，也不能對其做添加，修改，刪除等操作。

第一節(jié) 數(shù)組

數(shù)組是一個可以存放相同類型的多個元素對象的有序線性列表，這些元素可以是任意類型，也可以是元組。但是如果在一個數(shù)組中出現(xiàn)在了與其他元素類型不同的元素，那么編譯器就會報錯。

一個數(shù)組的完成類型為：Array<Element>。這里的Element表示存放到該數(shù)組中元素的類型，還有一種精簡的表示法：Array[Element]。
eg:
       //聲明一個存放整型元素的數(shù)組對象array，并對它創(chuàng)建一個空數(shù)組
       var array = Array<Int>()  ||  var array = [Int]()。

       //聲明一個Double類型常量數(shù)組，創(chuàng)建10個元素，每個元素都是2.0
       let a = [Double](repeating: 2.0, count: 10)

不過我們更常用的是直接使用數(shù)組的字面量[1，2，3，4，5],這樣數(shù)組的類型為Int。

       //聲明一個有4個元素的Double類型數(shù)組
       let  a = [1.0, 2.0, 3.0, 4.0]

swift 中還提供了＋操作符，可以把兩個數(shù)組拼接在一起，組成一個新的數(shù)組。

eg:
      //將[1, 2, 3] 和 [4, 5, 6]兩個數(shù)組拼接在一起，組成整型數(shù)組a
      //a的元素為[1, 2, 3, 4, 5, 6]
      let a  = [1, 2, 3] + [4, 5, 6]

      //變量數(shù)組b有三個Bool類型元素，對于變量數(shù)組可以使用+=為自己添加新元素，但是必須是和自己相同的類型的數(shù)組，不是元素類型對象
      var b = [false, true, false]
      b+= [true, false]

      //b的元素為[false, true, false, true, false]
      print("b = \(b)")

數(shù)組對象的元素訪問：如果訪問指定元素，可以通過下標(biāo)操作符[]來獲得，若索引值超出了數(shù)組本身大小，那么程序會引發(fā)異常

eg:
       let a = [1, 2, 3, 4, 5]
 
       // 這里讀取數(shù)組a的索引0的元素，
       // 即第一個元素，并為常量x初始化
       let x = a[0]

數(shù)組的幾個基本操作

count：獲取數(shù)組個數(shù)
isEmpty：判斷數(shù)組是否為空
contains(:)：判斷數(shù)組是否包含某個元素
append(:)：在該變量數(shù)組最后面添加元素
insert(_:at:)：在該變量數(shù)組指定位置添加元素，原本的元素被移動到新元素后面
remove(at:)：在該變量數(shù)組中移除指定位置的元素

注意：數(shù)組字面量(例如:[1,2,3])，本身是一個常量，如果我們對數(shù)組字面量進(jìn)行添加等操作，則會引起編譯器報錯。

第二節(jié) 集合

一個集合也能存放多個相同類型的元素，與數(shù)組不同的是：
1:一個集合不允許出現(xiàn)兩個相同的元素
2:集合中的元素是無序的
3:并不是所有的類型對象都能作為集合的元素，不過swift的基本類型都可以

一個集合的完整類型為：Set<Element: Hashable>，集合沒有精簡表示法。
我們可以使用集合的構(gòu)造方法創(chuàng)建一個空集合，也可以使用數(shù)組字面量構(gòu)建一個集合
eg:
      // 我們通過集合的構(gòu)造方法來構(gòu)造一個空的集合變量setA，
      // setA集合對象的每個元素都是Int類型對象
      var setA = Set<Int>()”

      // 我們這里還可以通過集合的不定參數(shù)個數(shù)的構(gòu)造方法來創(chuàng)建一個含有指定元素     的集合
      setA = Set<Int>(arrayLiteral: 1, 2, 3, 4)”
 
      // 這里我們通過數(shù)組字面量來創(chuàng)建一個集合常量setB，
      // 這里需要對setB顯式指定類型
      let setB: Set<Float> = [1.0, 0.5, 2.0]
 
      // 我們也可以用空的數(shù)組字面量來構(gòu)造一個空的集合
      setA = []”

元素集合的訪問不能像數(shù)組通過索引值，因為它是無序的，可以通過for-in循環(huán)，也可以通過flatMap方法，有選擇性的將集合元素取出。

集合的幾個基本操作

count：獲取集合個數(shù)
isEmpty：判斷集合是否為空
contains(:)：判斷集合是否包含某個元素
insert(:at:)：在該變量集合指定位置添加元素，如以存在，原本的元素被覆蓋，保證唯一性
remove(at:)：在該變量集合中移除指定位置的元素

第三節(jié) 字典

字典與數(shù)組和集合不同，它是以一種鍵-值對的形式存儲元素的，字典中不允許出兩個相同的鍵，但是不同的鍵可以對應(yīng)相同的值，字典的元素也是無序的。字典中鍵的類型與值的類型都是在聲明中直接確定的，每個鍵的類型應(yīng)該一致，每個值的類型也應(yīng)該一致，鍵的類型和值的類型可以相同也可以不同。

字典的完整類型為：Dictionary<Key: Hashable, Value>,這里的key表示鍵的類型，value表示值的類型，字典也有精簡表示法：[key : value].

eg:
      //使用字典默認(rèn)的構(gòu)造方式創(chuàng)建一個空的字典變量
      //鍵的類型為String，值得類型為Int
     var a = Dictionary<String: Int>()

     // 通過字典的不定參數(shù)個數(shù)的構(gòu)造方法創(chuàng)建一個字典對象，
     // 這里通過元組將字典的鍵值對進(jìn)行捆綁，
     // 元組的第一個元素是鍵，第二個元素是值。
     a = Dictionary<String, Int>(dictionaryLiteral: ("one", 1), ("two", 2), ("three", 3))

     //使用精簡表示法創(chuàng)建一個空的字典變量
     var a = [String : Int]()
      

對字典的值的訪問類似于數(shù)組對元素的訪問，可以通過下標(biāo)操作符對字段的值進(jìn)行訪問，例如對于一個這樣的字典對象dict［String ：Int］，我們可以通過dict["String"] 的方式來訪問鍵“String”對應(yīng)的值，不過這里得到的值是一個Optional對象，因為如果指定的鍵對應(yīng)的值不存在，會返回空。

eg:
      //聲明一個字典常量dict,類型為[String : Int]
      let dict = ["one":1, "two":2, "three":3]

      //訪問鍵"one" 對應(yīng)的值，得到1
      let one_value = dict["one"]

      //這里訪問鍵"four" 對應(yīng)的值將得到一個空值

字典的幾個基本操作

count: 獲取字典的鍵值對元素個數(shù)
isEmpty：判斷字典是否為空
keys：獲取字典對象的所有鍵值
values：獲取字典對象的所有值
updateValue(_:forKey:)：更新一個鍵對應(yīng)的值
removeValue(forKey:)： 將指定的鍵的元素移除

注意：這里的keys和values返回的類型為LazyMapCollection，它與集合類型類似，不能通過下標(biāo)訪問元素，一般通過for-in循環(huán)迭代訪問；變量字典還能通過調(diào)用下標(biāo)方式來新增一個鍵值對或修改一個鍵對應(yīng)的值。