类型(三) – 数组

排序

只要数组存储的元素类型采用了 Comparable 协议，就可以使用 sorted() 和sort() 方法，前者返回一个已排序的数组，后者修改数组。

var names = ["Taylor", "Timothy", "Tyler", "Thomas", "Tobias", "Tabitha"]
let numbers = [5, 3, 1, 9, 5, 2, 7, 8]

// ["Tabitha", "Taylor", "Thomas", "Timothy", "Tobias", "Tyler"]
let sorted = names.sorted()

实现自己的排序方式：编写一个闭包，接受两个字符串，如果第一个字符串应在第二个字符串之前排序，则返回 true。

names.sort {
    print("Comparing \($0) and \($1)")
    
    if ($0 == "Taylor") {
        return true
    } else if ($1 == "Taylor") {
        return false
    } else {
        return $0 < $1
    }
}

下面是输出结果：

Comparing Timothy and Taylor
Comparing Tyler and Timothy
Comparing Thomas and Tyler
Comparing Thomas and Timothy
Comparing Thomas and Taylor
Comparing Tobias and Tyler
Comparing Tobias and Timothy
Comparing Tabitha and Tyler
Comparing Tabitha and Tobias
Comparing Tabitha and Timothy
Comparing Tabitha and Thomas
Comparing Tabitha and Taylor

采用 Comparable 还可以实现两种更有用的方法： min() 和 max() 。

let lowest = numbers.min()
let highest = numbers.max()

对于字符串， min() 返回排序后排在最前面的字符串，而 max() 返回排在最后的字符串。

遵守 Comparable 协议

基本的 Dog 结构，它保存了一些信息:

struct Dog {
    var breed: String
    var age: Int
}

创建三只狗，并将它们分组到一个数组中：

let poppy = Dog(breed: "Poodle", age: 5)
let rusty = Dog(breed: "Labrador", age: 2)
let rover = Dog(breed: "Corgi", age: 11)
var dogs = [poppy, rusty, rover]

由于 Dog 结构不遵守 Comparable 协议，无法在 dogs 数组上获得简单的 sort() 和 sorted() 方法。

Dog 采用 Comparable 协议

struct Dog: Comparable {
    var breed: String
    var age: Int

	// 重载 < 操作符
    static func <(lhs: Dog, rhs: Dog) -> Bool {
        return lhs.age < rhs.age
    }
    
	// 重载 == 操作符
    static func==(lhs: Dog, rhs: Dog) -> Bool {
        return lhs.age == rhs.age
    }
}

dogs 数组的排序

dogs.sort()

添加和删除项目

如果要将两个数组添加到一起，可以使用 + 或 += 就地添加。

let poppy = Dog(breed: "Poodle", age: 5)
let rusty = Dog(breed: "Labrador", age: 2)
let rover = Dog(breed: "Corgi", age: 11)
var dogs = [poppy, rusty, rover]

let beethoven = Dog(breed: "St Bernard", age: 8)
dogs += [beethoven]

如果在删除项目时，数组有可能是空的，请使用 popLast() 代替，这样就可以安全地检查返回值：

if let dog = dogs.popLast() {
    // do stuff with `dog`
}

空判断与容量

空判断使用 isEmpty 属性，如果数组中没有添加项，则返回 true。通过 reserveCapacity() 方法，可以告诉 iOS 打算在数组中存储多少个项目。这并不是一个硬性限制，例如，如果你预留了 10 个容量，那么你就可以继续存储 20 个，但它确实允许 iOS 通过确保你有足够的空间来满足你的建议容量来优化对象存储。

import Foundation

let start = CFAbsoluteTimeGetCurrent()

var array = Array(1...1000000)
array.reserveCapacity(1000000)
array.reserveCapacity(1000000)

let end = CFAbsoluteTimeGetCurrent() - start
print("Took \(end) seconds")

连续数组

Swift 提供两种主要的数组，但几乎每次都只使用一种。首先，让我们来解读一下语法：你应该知道，这两行代码在功能上是完全相同的：

let array1 = [Int]()
let array2 = Array<Int>()

第一行是第二行的语法糖，连续数组的声明如下所示。

let array3 = ContiguousArray<Int>(1...1000000)

连续数组具有您所熟悉的所有属性和方法 – count , sort() , min() , map() 等等，但由于所有项目都保证连续存储（即彼此相邻），因此可以提高性能。

let array2 = Array<Int>(1...1000000)
let array3 = ContiguousArray<Int>(1...1000000)

var start = CFAbsoluteTimeGetCurrent()
array2.reduce(0, +)
var end = CFAbsoluteTimeGetCurrent() - start
print("Took \(end) seconds")

start = CFAbsoluteTimeGetCurrent()
array3.reduce(0, +)
end = CFAbsoluteTimeGetCurrent() - start
print("Took \(end) seconds")

如果您希望在您的应用程序或游戏中获得额外的性能提升，您一定要试试 ContiguousArray 。