Swift 数组(Array)

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

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

注意: Swift 的Array类型被桥接到Foundation中的NSArray类。 更多关于在Foundation和Cocoa中使用Array的信息，参见 Using Swift with Cocoa and Obejective-C(Swift 3.0.1) 中 使用 Cocoa 数据类型部分。

数组的简单语法

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

创建一个空数组

我们可以使用构造语法来创建一个由特定数据类型构成的空数组：

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

*注意：通过构造函数的类型，someInts的值类型被推断为[Int]。

或者，如果代码上下文中已经提供了类型信息，例如一个函数参数或者一个已经定义好类型的常量或者变量，我们可以使用空数组语句创建一个空数组，它的写法很简单：[]（一对空方括号）：

someInts.append(3)
// someInts 现在包含一个 Int 值
someInts = []
// someInts 现在是空数组，但是仍然是 [Int] 类型的。

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

Swift 中的Array类型还提供一个可以创建特定大小并且所有数据都被默认的构造方法。我们可以把准备加入新数组的数据项数量（count）和适当类型的初始值（repeating）传入数组构造函数：

var threeDoubles = Array(repeating: 0.0, count: 3)
// threeDoubles 是一种 [Double] 数组，等价于 [0.0, 0.0, 0.0]

通过两个数组相加创建一个数组

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

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]

用数组字面量构造数组

我们可以使用数组字面量来进行数组构造，这是一种用一个或者多个数值构造数组的简单方法。数组字面量是一系列由逗号分割并由方括号包含的数值：[value 1, value 2, value 3]。
下面这个例子创建了一个叫做shoppingList并且存储String的数组：

var shoppingList: [String] = ["Eggs", "Milk"]
// shoppingList 已经被构造并且拥有两个初始项。

shoppingList变量被声明为“字符串值类型的数组“，记作[String]。 因为这个数组被规定只有String一种数据结构，所以只有String类型可以在其中被存取。 在这里，shoppingList数组由两个String值（"Eggs" 和"Milk"）构造，并且由数组字面量定义。在这个例子中，字面量仅仅包含两个String值。匹配了该数组的变量声明（只能包含String的数组），所以这个字面量的分配过程可以作为用两个初始项来构造shoppingList的一种方式。

由于 Swift 的类型推断机制，当我们用字面量构造只拥有相同类型值数组的时候，我们不必把数组的类型定义清楚。 shoppingList的构造也可以这样写：

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

因为所有数组字面量中的值都是相同的类型，Swift 可以推断出[String]是shoppingList中变量的正确类型。

访问和修改数组

我们可以通过数组的方法和属性来访问和修改数组，或者使用下标语法。

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

print("The shopping list contains \(shoppingList.count) items.")
// 输出 "The shopping list contains 2 items."（这个数组有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(_:)方法在数组后面添加新的数据项：

shoppingList.append("Flour")
// shoppingList 现在有3个数据项，有人在摊煎饼

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

shoppingList += ["Baking Powder"]
// shoppingList 现在有四项了
shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 现在有七项了

可以直接使用下标语法来获取数组中的数据项，把我们需要的数据项的索引值放在直接放在数组名称的方括号中：

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

我们也可以用下标来改变某个已有索引值对应的数据值：

shoppingList[0] = "Six eggs"
// 其中的第一项现在是 "Six eggs" 而不是 "Eggs"

还可以利用下标来一次改变一系列数据值，即使新数据和原有数据的数量是不一样的。下面的例子把"Chocolate Spread"，"Cheese"，和"Butter"替换为"Bananas"和 "Apples"：

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 现在有6项

*注意：不可以用下标访问的形式去在数组尾部添加新项。

调用数组的insert(_:at:)方法来在某个具体索引值之前添加数据项：

shoppingList.insert("Maple Syrup", at: 0)
// shoppingList 现在有7项
// "Maple Syrup" 现在是这个列表中的第一项

这次insert(_:at:)方法调用把值为"Maple Syrup"的新数据项插入列表的最开始位置，并且使用0作为索引值。

类似的我们可以使用remove(at:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）：

let mapleSyrup = shoppingList.remove(at: 0)
// 索引值为0的数据项被移除
// shoppingList 现在只有6项，而且不包括 Maple Syrup
// mapleSyrup 常量的值等于被移除数据项的值 "Maple Syrup"

注意：如果我们试着对索引越界的数据进行检索或设置新值的操作，会引发一个运行期错误。我们可以使用索引值和数组的count属性进行比较来在使用某个索引之前先检验是否有效。

数据项被移除后数组中的空出项会被自动填补，所以现在索引值为0的数据项的值再次等于"Six eggs"：

firstItem = shoppingList[0]
// firstItem 现在等于 "Six eggs"

如果我们只想把数组中的最后一项移除，可以使用removeLast()方法而不是remove(at:)方法来避免我们需要获取数组的count属性。就像后者一样，前者也会返回被移除的数据项：

let apples = shoppingList.removeLast()
// 数组的最后一项被移除了
// shoppingList 现在只有5项，不包括 Apples
// apples 常量的值现在等于 "Apples" 字符串

数组的遍历

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

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

如果我们同时需要每个数据项的值和索引值，可以使用enumerated()方法来进行数组遍历。enumerated()返回一个由每一个数据项索引值和数据值组成的元组。我们可以把这个元组分解成临时常量或者变量来进行遍历：

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循环的介绍请参见for 循环。

借助closure，我们还可以使用Array对象的forEach方法:

shoppingList.forEach {print($0)}

通过closure参数化对数组元素的变形操作

从循环到map

假设我们有一个简单的Fibonacci序列：[0,1,1,2,3,5]。如果我们要计算每个元素的平方，怎么办呢？
一个最朴实的做法是for循环：

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循环执行的结果是相同的。显然，它比for循环更具表现力，并且也能把我们期望的结果定义成常量。当然，map并不是什么魔法，无非就是把for循环执行的逻辑，封装在了函数里，这样我们就可以把函数的返回值赋值给常量了，我们可以通过extension很简单的自己来实现map：

extension Array {
    func myMap<T>(_ transform: (Element) -> T) -> [T] {
        var tmp: [T] = []
        //如果明确的知道一个数组的容量大小，可以调用这个方法告诉系统这个数组至少需要的容量，避免在数组添加元素过程中重复的申请内存。
        tmp.reserveCapacity(count)
        for value in self {
            tmp.append(transform(value))
        }
        return tmp
    }
}

虽然和Swift标准库相比，MyMap的实现中去掉了和异常声明相关的部分。但它已经足以表现map的核心实现过程了。除了在append之前使用了reserveCapacity给新数组预留了空间之外，它的实现过程和一开始我们使用的for循环没有任何差别。
完成后，当我们在playground里测试的时候：

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

就会发现执行结果和之前的constSequence是一样的了。

参数化数组元素的执行动作

其实，仔细观察myMap的实现，就会发现它最大的意义，就是保留了遍历Array的过程，而把执行的动作留给了myApp的调用者通过参数去定制。而这，就是我们一开始提到的用closure来参数化对数组的操作行为的含义。
有了这样的思路之后，我们就可以把各种常用的带有遍历行为的操作，定制成多种不同的遍历"套路"，而把对数组中每一个元素的处理动作留给函数的调用者。但是别急，在开始自动动手造轮子之前，Swift library已经为我们准备了一些，例如：
首先，是找到最小、最大值，对于这类操作来说，只要数组中的元素实现了"Equatable"protocol，我们甚至无需定义对元素的具体操作：

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

使用min和max很安全，因为当数组为空时，这两个方法将返回nil。其次，过滤出满足特定条件的元素，我们只要通过参数制定筛选规则就好了：

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

比较数组相等或以特定元素开始。对这类操作，我们需要提供两个内容，一个是要比较的数组，另一个则是比较的规则：

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

最原始的for循环的替代品：

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

注意：它和map的一个重要区别：forEach并不处理closure参数的返回值。因此它只适合用来对数组中的元素进行一些操作，而不能用来产生返回结果。

对数组进行排序，这时，我们需要通过参数制定的是排序规则：

sorted(by:)的用法是很直接的，它默认采用升序排列。同事，也允许我们通过by自定义排序规则。在这里>是 { $0 > $1 } 的简写形式。Swift中很多在不影响语义的情况下的简写形式。

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

partition(by:)则会先对传递给它的数组进行重排，然后根据指定的条件在重排的结果中返回一个分界点位置。这个分界点分开的两部分中，前半部分的元素都不满足指定条件；后半部分都满足指定条件。而后，我们就可以使用range operator来访问者两个区间形成的Array对象。

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

把数组中的所有内容“合并”成某种形式的值，对这类操作，我们需要指定的，是合并前的初始值，以及"合并"的规则。例如，我们计算fibonacci中所有元素的和：

fibonacci.reduce(0, +)   //12

在这里，初始值为0，和第二个参数+,则是 { $0 + $1 }的缩写。

filter

filter的用法在Array中过滤满足特定条件的元素。而这个条件，就是通过filter的closure参数来确定的：

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

按照实现的map的思路，我们可以自己来实现一个filter：

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

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

在上面的实现里，最核心的环节就是通过where条件的for循环找到原数组中符合条件的元素，然后把它们一一添加到temp中，并最终返回给函数的调用者。然后，我们测试下myFilter：

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

结果应该是和标准库中的自带的filter是一样的。理解filter之后，我们就可以自行定义一些标准库中没有的方法。例如：
剔除掉数组中满足条件的元素：

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

我们只要把调用转发给filter,然后把指定的条件取反就好了。这样，提出元素的代码语义上就会更好看一些：

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

另一个基于filter语义的常用操作是判断数组中是否存在满足条件的元素。下面的代码可以完成任务：

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

但这样做在性能上并不理想，因为即便找到了满足条件的元素，也要遍历完整个数组，这显然是没有必要的。Swift标准库中，提供了一个更方便的方法：

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

contains的一个好处就是只要遇到满足条件的元素，函数的执行就终止了。基于这个contains，我们还可以给Array添加一个新的方法，用来判断Array中所有的元素是否满足特定的条件：

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

在allMatch的实现里，只要没有不满足条件的元素，也就是所有的元素都满足条件了。我们可以用下面的代码测试一下：

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

reduce

除了用一个数组生成一个新的数组，有时，我们会希望把一个数组变成某种形式的值。例如,之前我们提到的求和：

fibonacci.reduce(0, +) // 12

了解reduce的进一步用法之前，我们先自己实现一个：

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的实现就是把for循环迭代相加的过程给封装了起来。然后，用下面的代码测试一下，就会发现和标准库里的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
https://www.jianshu.com/p/8730de8d8778