Swift - 数组（Array）

数组

数组是swift中最普通的集合，数组是有序的容器，并且容器中的每一个元素都是相同的类型，可以随机访问元素,相同的值可以多次出现在一个数组的不同位置中。

数组的简单语法

写Swift数组应该遵循像Array<Element>这样的形式，其中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 值，值为3
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"）构造，并且由数组字面量定义。

注意：shoppingList数组被声明为变量（var关键字创建）而不是常量（let创建）是因为以后可能会有更多的数据项被插入其中。

在这个例子中，字面量仅仅包含两个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"

注意：第一项在数组中的索引值是0而不是1。 Swift 中的数组索引总是从零开始。

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

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:)方法来移除数组中的某一项。这个方法把数组在特定索引值中存储的数据项移除并且返回这个被移除的数据项（我们不需要的时候就可以无视它）：

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

注意：如果我们试着对索引越界的数据进行检索或者设置新值的操作，会引发一个运行期错误。我们可以使用索引值和数组的count属性进行比较来在使用某个索引之前先检验是否有效。除了当count等于 0 时（说明这是个空数组），最大索引值一直是count - 1，因为数组都是零起索引。

数据项被移除后数组中的空出项会被自动填补，所以现在索引值为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 x in shoppingList.dropFirst(){
 print(x) //
}

/*
 Milk
 Flour
 Baking Powder
 Bananas
 */

遍历数组，但是不包括最后一个或者几个元素

for x in shoppingList.dropLast(){
 print(x)
}
/*
 Six eggs
 Milk
 Flour
 Baking Powder
 */
for x in shoppingList.dropLast(3){
    print(x)
}
/*
 Six eggs
 Milk
 */

数组的可变性

例如：我们创建一个包含数字的数组，可以使用下列方法：

let fibs = [0,1,1,2,3,4,5]

如果我们尝试着修改数组，我们会获得一个编译错误。fibs.append(6) 如：cannot use mutating member on immutable value:fibs is a let constant.这是因为数组使用了let，被定义为常量。在许多情况下，这是正确的操作，这样我们可以保证数组不被改变。如果我们想数组能够成为变量，我们需要使用var关键字

var mutableFibs = [0,1,2,3,4,5]

前面也提到了使用append函数添加单一数据(single element)，其实还可以添加多个数据(sequence of elements)

mutableFibs.append(6)  //[0, 1, 2, 3, 4, 5, 6]
mutableFibs.append(contentsOf: [20,30])  //[0, 1, 2, 3, 4, 5, 6, 20, 30]
mutableFibs += [8,9]  //[0, 1, 2, 3, 4, 5, 6, 20, 30, 8, 9] 

数组是值类型

即当我们为变量赋值一个存在的数组，数组仅仅是进行拷贝内容。例如：

var x = [1,2,3,4]
var y = x
y.append(5)
print("y = \(y), x = \(x)") //y = [1, 2, 3, 4, 5], x = [1, 2, 3, 4]

数组的转换

map函数   

public func map<T>(_ transform: (Element) throws -> T) rethrows -> [T]

map 方法接受一个闭包作为参数， 然后它会遍历整个数组，并对数组中每一个元素执行闭包中定义的操作。 相当于对数组中的所有元素做了一个映射

，这是非常普遍的操作。例如：我们经常写这样的代码，创建一个新数组，然后遍历存在的数组，将数组中的每一个元素都进行某个操作，并拼接到新数组中,数组中的每个数乘 2

let array = [2,3,4,5,6]
var result: [Int] = []
for i in array {
    result.append(i * 2)
}
result //[4, 6, 8, 10, 12]

对于上面的操作，swift为我们提供了更加简单的操作方式，采用函数式编程思想，使用map函数,该函数将遍历数组的每一个元素并进行相应的操作,最终得到一个全新的数组.

let mapResult = array.map { $0 * 2 }
mapResult //[4, 6, 8, 10, 12]

map函数的内部实现

extension Array {
    func map<T>(_ transform: (Element) -> T) -> [T] {
        var result: [T] = []
        result.reserveCapacity(count)
        for x in self {
            result.append(transform(x))
        }
        return result
    }
}

index函数

找到具体元素的位置,第一次出现的位置

if let index = array.index(where: { element -> Bool in return element == 4 }) {
  print("index = \(index)") //index = 2
}

另外一个例子：

let students = ["Kofi", "Abena", "Peter", "Kweku", "Akosua"]
if let i = students.index(where: { $0.hasPrefix("A") }) {
    print("\(students[i]) starts with 'A'!")
}
// Prints "Abena starts with 'A'!"

filter函数

对数组进行过滤内容

let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let shortNames = cast.filter { $0.characters.count < 5 }
print(shortNames)
// Prints "["Kim", "Karl"]"

filter内部实现

extension Array {
    func filter(_ isIncluded: (Element) -> Bool) -> [Element] {
        var result: [Element] = []
        for x in self where isIncluded(x) {
            result.append(x)
        }
        return result
    }
}

组合map,filter写出更简单的表达

如：查找100以下所有的偶数

let res = (1..<10).map{$0 * $0}.filter{$0 % 2 == 0}
print(res) //[4, 16, 36, 64]

reduce函数

对于map,filter都是在一个数组的基础上产生一个新数组或者修改数组，然后有时候，你想组合所有的元素到一个新值。例如：计算所有元素的和，我们能够使用如下代码：

let number = [0,1,1,2,3,4,5]
var total = 0
for num in number {
    total = total + num
}
print("total = \(total)") //total = 16

reduce方法使用了这种模式，并且抽象为两个部分，一个初始值，一个是函数用于组合中间值和元素值，使用reduce，我们的代码如下：

let sum = number.reduce(0){total, num in total + num}
//因为操作符+也是函数，所以我们可以直接使用+号
let shortSum = fibs.reduce(0, +)
print("sum = \(sum),shortSum = \(shortSum)") //sum = 16,shortSum = 16

注意：输出的结果类型并不一定跟元素的类型一样，例如：我们想转换integer到string

let stringArray = number.reduce(""){str, num in str + "\(num)"}
print("stringArray = \(stringArray)") //stringArray = 0112345

reduce的内部实现

extension Array {
    func reduce<Result>(_ initialResult: Result, _ nextPartialResult: (Result, Element) -> Result) -> Result {
        var result = initialResult
        for x in self {
            result = nextPartialResult(result, x)
        }
        return result
    }
}

forEach函数

forEach,就像一个循环，传递一个函数功能用于执行序列中的每一个元素。但是不像map，forEach并不返回任意内容。

for element in [1,2,3] {
   print(element)
}

[1,2,3].forEach { element in
    print(element)
}

上下对比一下也没有看到优势，但是它能够随意使用，如果你想为集合执行单一功能的操作，传递一个函数名给forEach而不是一个比包表达式，这样能够看起来更加简单和精准的代码。例如：在你的视图控制器之内，你想添加子视图（ subviews）的数组到主视图（main view），仅仅只需要 theViews.forEach(view.addSubview)

然而，对于for循环和forEach还是存在一些区别的，例如：如果使用for循环执行返回一条语句，使用forEach重写将更好.对于多语句的遍历，不要使用forEach。

flatMap函数

通过为序列中的每一个元素进行转换，即执行闭包，返回的数组是包含串行的结果.

let numbers = [1, 2, 3, 4]
let mapped = numbers.map { Array(repeating: $0, count: $0) }
print("mapped = \(mapped)") //mapped = [[1], [2, 2], [3, 3, 3], [4, 4, 4, 4]]
let flatMapped = numbers.flatMap { Array(repeating: $0, count: $0) }
print("flatMapped = \(flatMapped)") //flatMapped = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

flatMap组合元素来自不同的数组

let suits = ["♠", "♥", "♣", "♦"]
let ranks = ["J","Q","K","A"]
let results = suits.flatMap { suit in
    ranks.map { rank in
        (suit,rank)
    }
}
print("results = \(results)")
//results = [("♠", "J"), ("♠", "Q"), ("♠", "K"), ("♠", "A"), ("♥", "J"), ("♥", "Q"), ("♥", "K"), ("♥", "A"), ("♣", "J"), ("♣", "Q"), ("♣", "K"), ("♣", "A"), ("♦", "J"), ("♦", "Q"), ("♦", "K"), ("♦", "A")]

数组的切片

extension Array {
    subscript(input: [Int]) -> ArraySlice<Element> {
        get {
            var result = ArraySlice<Element>()
            for i in input {
                result.append(self[i])
            }
            return result
        }
        
        set {
            for (index, i) in input.enumerated() {
                self[i] = newValue[index]
            }
        }
    }
}

var arr = [1,2,3,4,5]
arr[[0,2,3]] //[1, 3, 4]
arr[[0,2,3]] = [-1,-3,-4]
arr //[-1, 2, -3, -4, 5]