demo鏈接：https://share.weiyun.com/5FHZyK3

數(shù)組使用有序列表存儲同一類型的多個值。相同的值可以多次出現(xiàn)在一個數(shù)組的不同位置中。

注意: Swift 的Array類型被橋接到Foundation中的NSArray類。 更多關于在Foundation和Cocoa中使用Array的信息，參見 Using Swift with Cocoa and Obejective-C(Swift 3.0.1) 中 使用 Cocoa 數(shù)據(jù)類型部分。

數(shù)組的簡單語法

寫 Swift 數(shù)組應該遵循像Array<Element>這樣的形式，其中Element是這個數(shù)組中唯一允許存在的數(shù)據(jù)類型。我們也可以使用像[Element]這樣的簡單語法。盡管兩種形式在功能上是一樣的，但是推薦較短的那種，而且在本文中都會使用這種形式來使用數(shù)組。

創(chuàng)建一個空數(shù)組

我們可以使用構造語法來創(chuàng)建一個由特定數(shù)據(jù)類型構成的空數(shù)組：

var someInts = [Int]()
print("someInts is of type [Int] with \(someInts.count) items.")
// 打印 "someInts is of type [Int] with 0 items."

*注意：通過構造函數(shù)的類型，someInts的值類型被推斷為[Int]。

或者，如果代碼上下文中已經(jīng)提供了類型信息，例如一個函數(shù)參數(shù)或者一個已經(jīng)定義好類型的常量或者變量，我們可以使用空數(shù)組語句創(chuàng)建一個空數(shù)組，它的寫法很簡單：[]（一對空方括號）：

someInts.append(3)
// someInts 現(xiàn)在包含一個 Int 值
someInts = []
// someInts 現(xiàn)在是空數(shù)組，但是仍然是 [Int] 類型的。

創(chuàng)建一個帶有默認值的數(shù)組

Swift 中的Array類型還提供一個可以創(chuàng)建特定大小并且所有數(shù)據(jù)都被默認的構造方法。我們可以把準備加入新數(shù)組的數(shù)據(jù)項數(shù)量（count）和適當類型的初始值（repeating）傳入數(shù)組構造函數(shù)：

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles 是一種 [Double] 數(shù)組，等價于 [0.0, 0.0, 0.0]

通過兩個數(shù)組相加創(chuàng)建一個數(shù)組

我們可以使用加法操作符（+）來組合兩種已存在的相同類型數(shù)組。新數(shù)組的數(shù)據(jù)類型會被從兩個數(shù)組的數(shù)據(jù)類型中推斷出來：

var anotherThreeDoubles = Array(repeating: 2.5, count: 3)
// anotherThreeDoubles 被推斷為 [Double]，等價于 [2.5, 2.5, 2.5]

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推斷為 [Double]，等價于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

用數(shù)組字面量構造數(shù)組

我們可以使用數(shù)組字面量來進行數(shù)組構造，這是一種用一個或者多個數(shù)值構造數(shù)組的簡單方法。數(shù)組字面量是一系列由逗號分割并由方括號包含的數(shù)值：[value 1, value 2, value 3]。
下面這個例子創(chuàng)建了一個叫做shoppingList并且存儲String的數(shù)組：

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已經(jīng)被構造并且擁有兩個初始項。

shoppingList變量被聲明為“字符串值類型的數(shù)組“，記作[String]。 因為這個數(shù)組被規(guī)定只有String一種數(shù)據(jù)結構，所以只有String類型可以在其中被存取。 在這里，shoppingList數(shù)組由兩個String值（"Eggs" 和"Milk"）構造，并且由數(shù)組字面量定義。在這個例子中，字面量僅僅包含兩個String值。匹配了該數(shù)組的變量聲明（只能包含String的數(shù)組），所以這個字面量的分配過程可以作為用兩個初始項來構造shoppingList的一種方式。

由于 Swift 的類型推斷機制，當我們用字面量構造只擁有相同類型值數(shù)組的時候，我們不必把數(shù)組的類型定義清楚。 shoppingList的構造也可以這樣寫：

var shoppingList = ["Eggs", "Milk"]

因為所有數(shù)組字面量中的值都是相同的類型，Swift 可以推斷出[String]是shoppingList中變量的正確類型。

訪問和修改數(shù)組

我們可以通過數(shù)組的方法和屬性來訪問和修改數(shù)組，或者使用下標語法。

可以使用數(shù)組的只讀屬性count來獲取數(shù)組中的數(shù)據(jù)項數(shù)量：

print("The shopping list contains \(shoppingList.count) items.")
// 輸出 "The shopping list contains 2 items."（這個數(shù)組有2個項）

使用布爾屬性isEmpty作為一個縮寫形式去檢查count屬性是否為0：

if shoppingList.isEmpty {
    print("The shopping list is empty.")
} else {
    print("The shopping list is not empty.")
}
// 打印 "The shopping list is not empty."（shoppinglist 不是空的）

也可以使用append(_:)方法在數(shù)組后面添加新的數(shù)據(jù)項：

shoppingList.append("Flour")
// shoppingList 現(xiàn)在有3個數(shù)據(jù)項，有人在攤煎餅

除此之外，使用加法賦值運算符（+=）也可以直接在數(shù)組后面添加一個或多個擁有相同類型的數(shù)據(jù)項：

shoppingList += ["Baking Powder"]
// shoppingList 現(xiàn)在有四項了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 現(xiàn)在有七項了

可以直接使用下標語法來獲取數(shù)組中的數(shù)據(jù)項，把我們需要的數(shù)據(jù)項的索引值放在直接放在數(shù)組名稱的方括號中：

var firstItem = shoppingList[0]
// 第一項是 "Eggs"

我們也可以用下標來改變某個已有索引值對應的數(shù)據(jù)值：

shoppingList[0] = "Six eggs"
// 其中的第一項現(xiàn)在是 "Six eggs" 而不是 "Eggs"

還可以利用下標來一次改變一系列數(shù)據(jù)值，即使新數(shù)據(jù)和原有數(shù)據(jù)的數(shù)量是不一樣的。下面的例子把"Chocolate Spread"，"Cheese"，和"Butter"替換為"Bananas"和 "Apples"：

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 現(xiàn)在有6項

*注意：不可以用下標訪問的形式去在數(shù)組尾部添加新項。

調用數(shù)組的insert(_:at:)方法來在某個具體索引值之前添加數(shù)據(jù)項：

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList 現(xiàn)在有7項
// "Maple Syrup" 現(xiàn)在是這個列表中的第一項

這次insert(_:at:)方法調用把值為"Maple Syrup"的新數(shù)據(jù)項插入列表的最開始位置，并且使用0作為索引值。

類似的我們可以使用remove(at:)方法來移除數(shù)組中的某一項。這個方法把數(shù)組在特定索引值中存儲的數(shù)據(jù)項移除并且返回這個被移除的數(shù)據(jù)項（我們不需要的時候就可以無視它）：

let mapleSyrup = shoppingList.remove(at: 0)
// 索引值為0的數(shù)據(jù)項被移除
// shoppingList 現(xiàn)在只有6項，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除數(shù)據(jù)項的值 "Maple Syrup"

注意：如果我們試著對索引越界的數(shù)據(jù)進行檢索或設置新值的操作，會引發(fā)一個運行期錯誤。我們可以使用索引值和數(shù)組的count屬性進行比較來在使用某個索引之前先檢驗是否有效。

數(shù)據(jù)項被移除后數(shù)組中的空出項會被自動填補，所以現(xiàn)在索引值為0的數(shù)據(jù)項的值再次等于"Six eggs"：

firstItem = shoppingList[0]
// firstItem 現(xiàn)在等于 "Six eggs"

如果我們只想把數(shù)組中的最后一項移除，可以使用removeLast()方法而不是remove(at:)方法來避免我們需要獲取數(shù)組的count屬性。就像后者一樣，前者也會返回被移除的數(shù)據(jù)項：

let apples = shoppingList.removeLast()
// 數(shù)組的最后一項被移除了
// shoppingList 現(xiàn)在只有5項，不包括 Apples
// apples 常量的值現(xiàn)在等于 "Apples" 字符串

數(shù)組的遍歷

我們可以使用for-in循環(huán)來遍歷所有數(shù)組中的數(shù)據(jù)項：

for item in shoppingList {
    print(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

如果我們同時需要每個數(shù)據(jù)項的值和索引值，可以使用enumerated()方法來進行數(shù)組遍歷。enumerated()返回一個由每一個數(shù)據(jù)項索引值和數(shù)據(jù)值組成的元組。我們可以把這個元組分解成臨時常量或者變量來進行遍歷：

for (index, value) in shoppingList. enumerated() {
    print("Item \(String(index + 1)): \(value)")
}
// Item 1: Six eggs
// Item 2: Milk
// Item 3: Flour
// Item 4: Baking Powder
// Item 5: Bananas

更多關于for-in循環(huán)的介紹請參見for 循環(huán)。

借助closure，我們還可以使用Array對象的forEach方法:

shoppingList.forEach {print($0)}

通過closure參數(shù)化對數(shù)組元素的變形操作

從循環(huán)到map

假設我們有一個簡單的Fibonacci序列：[0,1,1,2,3,5]。如果我們要計算每個元素的平方，怎么辦呢？
一個最樸實的做法是for循環(huán)：

var fibonacci = [0,1,1,2,3,5]
var squares = [Int]()

for value in fibonacci {
    squares.append(value * value)
}  

如果你覺得這還不是個足夠引起你注意的問題，那么，當我們要定義一個常量 squares 的時候，上面的代碼就完全無法勝任了。怎么辦呢？先看解決辦法：

//[0,1,1,4,9,25]
let constSquares = fibonacci.map { $0 * $0 }

上面的代碼，和之前的for循環(huán)執(zhí)行的結果是相同的。顯然，它比for循環(huán)更具表現(xiàn)力，并且也能把我們期望的結果定義成常量。當然，map并不是什么魔法，無非就是把for循環(huán)執(zhí)行的邏輯，封裝在了函數(shù)里，這樣我們就可以把函數(shù)的返回值賦值給常量了，我們可以通過extension很簡單的自己來實現(xiàn)map：

extension Array {
    func myMap<T>(_ transform: (Element) -> T) -> [T] {
        var tmp: [T] = []
        //如果明確的知道一個數(shù)組的容量大小，可以調用這個方法告訴系統(tǒng)這個數(shù)組至少需要的容量，避免在數(shù)組添加元素過程中重復的申請內存。
        tmp.reserveCapacity(count)
        for value in self {
            tmp.append(transform(value))
        }
        return tmp
    }
}

雖然和Swift標準庫相比，MyMap的實現(xiàn)中去掉了和異常聲明相關的部分。但它已經(jīng)足以表現(xiàn)map的核心實現(xiàn)過程了。除了在append之前使用了reserveCapacity給新數(shù)組預留了空間之外，它的實現(xiàn)過程和一開始我們使用的for循環(huán)沒有任何差別。
完成后，當我們在playground里測試的時候：

// [0,1,1,4,9,25]
let constSuquence1 = fibonacci.myMap { $0 * $0 }

就會發(fā)現(xiàn)執(zhí)行結果和之前的constSequence是一樣的了。

參數(shù)化數(shù)組元素的執(zhí)行動作

其實，仔細觀察myMap的實現(xiàn)，就會發(fā)現(xiàn)它最大的意義，就是保留了遍歷Array的過程，而把執(zhí)行的動作留給了myApp的調用者通過參數(shù)去定制。而這，就是我們一開始提到的用closure來參數(shù)化對數(shù)組的操作行為的含義。
有了這樣的思路之后，我們就可以把各種常用的帶有遍歷行為的操作，定制成多種不同的遍歷"套路"，而把對數(shù)組中每一個元素的處理動作留給函數(shù)的調用者。但是別急，在開始自動動手造輪子之前，Swift library已經(jīng)為我們準備了一些，例如：
首先，是找到最小、最大值，對于這類操作來說，只要數(shù)組中的元素實現(xiàn)了"Equatable"protocol，我們甚至無需定義對元素的具體操作：

fibonacci.min()  // 0
fibonacci.max()  // 5

使用min和max很安全，因為當數(shù)組為空時，這兩個方法將返回nil。其次，過濾出滿足特定條件的元素，我們只要通過參數(shù)制定篩選規(guī)則就好了：

fibonacci.filter { $0 % 2 == 0 }

比較數(shù)組相等或以特定元素開始。對這類操作，我們需要提供兩個內容，一個是要比較的數(shù)組，另一個則是比較的規(guī)則：

//false
fibonacci.elementsEqual([0,1,1], by: { $0 == $1 })
//true
fibonacci.starts(with: [0,1,1], by: { $0 == $1 })

最原始的for循環(huán)的替代品：

fibonacci.forEach { print($0) }
// 0 
// 1
// ...

注意：它和map的一個重要區(qū)別：forEach并不處理closure參數(shù)的返回值。因此它只適合用來對數(shù)組中的元素進行一些操作，而不能用來產生返回結果。

對數(shù)組進行排序，這時，我們需要通過參數(shù)制定的是排序規(guī)則：

sorted(by:)的用法是很直接的，它默認采用升序排列。同事，也允許我們通過by自定義排序規(guī)則。在這里>是 { $0 > $1 } 的簡寫形式。Swift中很多在不影響語義的情況下的簡寫形式。

// [0,1,1,2,3,5]
fibonacci.sorted()
// [5,3,2,1,1,0]
fibonacci.sorted(by: >)

partition(by:)則會先對傳遞給它的數(shù)組進行重排，然后根據(jù)指定的條件在重排的結果中返回一個分界點位置。這個分界點分開的兩部分中，前半部分的元素都不滿足指定條件；后半部分都滿足指定條件。而后，我們就可以使用range operator來訪問者兩個區(qū)間形成的Array對象。

let privot = fibonacci.partition(by: { $0 < 1 })
fibonacci[0 ..< privot] // [5, 1, 1, 2, 3]
fibonacci[privot ..< fibonacci.endIndex] //[0]

把數(shù)組中的所有內容“合并”成某種形式的值，對這類操作，我們需要指定的，是合并前的初始值，以及"合并"的規(guī)則。例如，我們計算fibonacci中所有元素的和：

fibonacci.reduce(0, +)   //12

在這里，初始值為0，和第二個參數(shù)+,則是 { $0 + $1 }的縮寫。

filter

filter的用法在Array中過濾滿足特定條件的元素。而這個條件，就是通過filter的closure參數(shù)來確定的：

var fibonacci = [0,1,1,2,3,5]
//[0,2]
fibonacci.filter { $0 % 2 == 0}

按照實現(xiàn)的map的思路，我們可以自己來實現(xiàn)一個filter：

extension Array {
    func myFilter(_ predicate: (Element) -> Bool) -> [Element] {
        var temp: [Element] = []

        for value in self where predicate(value) {
            temp.append(value)
        }
        
        return temp
    }
}

在上面的實現(xiàn)里，最核心的環(huán)節(jié)就是通過where條件的for循環(huán)找到原數(shù)組中符合條件的元素，然后把它們一一添加到temp中，并最終返回給函數(shù)的調用者。然后，我們測試下myFilter：

fibonacci.myFilter { $0 % 2 == 0 } // [0,2]

結果應該是和標準庫中的自帶的filter是一樣的。理解filter之后，我們就可以自行定義一些標準庫中沒有的方法。例如：
剔除掉數(shù)組中滿足條件的元素：

extension Array {
    func reject(_ predicate: (Element) -> Bool) -> [Element]{
        return filter { !predicate($0) }
    }
}

我們只要把調用轉發(fā)給filter,然后把指定的條件取反就好了。這樣，提出元素的代碼語義上就會更好看一些：

fibonacci.reject { $0 % 2 == 0 } //[1,1,3,5]

另一個基于filter語義的常用操作是判斷數(shù)組中是否存在滿足條件的元素。下面的代碼可以完成任務：

fibonacci.filter { $0 % 2 == 0}.count > 0 //true

但這樣做在性能上并不理想，因為即便找到了滿足條件的元素，也要遍歷完整個數(shù)組，這顯然是沒有必要的。Swift標準庫中，提供了一個更方便的方法：

fibonacci.containts { $0 % 2 == 0} //true

contains的一個好處就是只要遇到滿足條件的元素，函數(shù)的執(zhí)行就終止了。基于這個contains，我們還可以給Array添加一個新的方法，用來判斷Array中所有的元素是否滿足特定的條件：

extension Array {
    func allMatch(_ predicate: (Element) -> Bool) -> Bool{
        return !contains { !predicate($0) }
    }
}

在allMatch的實現(xiàn)里，只要沒有不滿足條件的元素，也就是所有的元素都滿足條件了。我們可以用下面的代碼測試一下：

let events = [2,4,6,8]
events.allMatch { $0 % 2 == 0 } // true

reduce

除了用一個數(shù)組生成一個新的數(shù)組，有時，我們會希望把一個數(shù)組變成某種形式的值。例如,之前我們提到的求和：

fibonacci.reduce(0, +) // 12

了解reduce的進一步用法之前，我們先自己實現(xiàn)一個：

extension Array {
    func myReduce<T>(_ initial: T, _ next: (T, Element) -> T) -> T {
        var temp = initial
        for value in self {
            temp = next(temp,value)
        }   
        return temp
    }
}

從上面可以看出，reduce的實現(xiàn)就是把for循環(huán)迭代相加的過程給封裝了起來。然后，用下面的代碼測試一下，就會發(fā)現(xiàn)和標準庫里的reduce一樣了。

fibonacci.myReduce(0,+) //12

除了求和以外，我們還可以把fibonacci reduce成一個字符串：

let str = fibonacci.myReduce("") { str, num in
    return str + "\(num)"
}
// 011235

參考鏈接：
http://www.swift51.com/swift4.0/chapter2/04_Collection_Types.html
http://www.lxweimin.com/p/8730de8d8778