Swift（02）——Array（数组）

Swift 数组使用有序列表存储 同一类型 的多个值，这点相对于Objective-C是有所不同的，OC中同一个数组，可以存放不同类型的元素。Swift 数组会强制检测元素的类型，如果类型不同则会报错。

数组初始化

创建空数组

//下面4种方式创建的空数组是等价的
var emptyArray = [Int]() // 初始化器1 - [类型]()
var emptyArray = Array<Int>() // 初始化器2 - Array<类型>()
var emptyArray : [Int] = []
var emptyArray : Array<Int> = []

创建有默认值的数组

创建可变数组，若使用 let 代替 var ，则数组不可变

var allZeros = Array<Int>(repeating: 0, count: 5)  //[0, 0, 0, 0, 0] <Int>可省略

var allZeros = [Int](repeating: 0, count: 5)  //[0, 0, 0, 0, 0]

var numbers:[Int] = [0, 2, 4, 5]
//[Int]可以省去，系统能够检测出数组的类型，直接用字面量方式创建数组
var numbers = [0, 2, 4, 5]

数组遍历

1.For-In

let letters = ["D", "B", "E", "A", "P", "F"]  
for value in letters {
    print(value)
}

2.ForEach

ForEach无法使用break / continue 来跳出 / 跳过循环
使用return只能退出当前一次的循环执行体

let numbers = [Int](2 ... 6)
numbers.forEach { (num) in
    print(num)
}

3.enumerated()，可以同时得到索引和值

 let numbers = [Int](2 ... 6)
 for (index, num) in numbers.enumerated() {
    print("第\(index+1)个元素为\(num)")
 }

4.Iterator

  let numbers = [Int](2 ... 6)
  var numIterator = numbers.makeIterator()
  while let num = numIterator.next() {
    print(num)
  }

索引

startIndex 返回数组第一个元素的位置，对于Array来说，永远都是0。
endIndex 返回数组最后一个元素索引+1的位置，对于Array来说，等同于count。
对于空数组来说，startIndex等于endIndex。
通过索引遍历数组，可以使用indices，如：

let numbers = [Int](2 ... 6)
// numbers.indices，等同于 0 ..< numbers.count
for i in numbers.indices {  
    print(i)
  }

数组查找

判断是否包含指定元素contains(_:)
判断数组是否包含指定条件的元素contains(where:)

let numbers = [2, 5, 12, 6, 8]
 if numbers.contains(10) {
    // 是否存在元素10
 }
 if numbers.contains(where: { $0 > 10}) {
    // 是否存在 > 10 的元素
 }

判断数组的每一个元素是否都符合指定条件allSatisfy(_:)

let fruits = ["orange", "cherry", "mango", "strawberry"]
print(fruits.allSatisfy({ $0.count > 5 })) //false
print(fruits.allSatisfy({ $0.count < 11 })) //true

查找元素
length获取数组长度。
isEmpty判断数组是否为空数组。
fisrt返回数组第一个元素（Optional），若数组为空，则返回nil。
last返回数组最后一个元素（Optional），若数组为空，则返回nil。
fisrt(where:)返回数组第一个符合指定条件的元素（Optional）。
last(where:)返回数组最后一个符合指定条件的元素（Optional）。

let numbers = [2, 5, 12, 6, 8]
numbers.first // Optional(2)
numbers.last // Optional(8)
print(numbers.first(where: { $0 > 5 })) // Optional(12)
print(numbers.last(where: { $0 < 8 })) // Optional(6)

查找索引
firstIndex(of:)返回给定的元素在数组中第一次出现的位置（Optional）
lastIndex(of:)返回给定的元素在数组中最后一次出现的位置（Optional）
firstIndex(where:)返回符合给定条件的元素在数组中第一次出现的位置（Optional）
lastIndex(where:)返回符合给定条件的元素在数组中最后一次出现的位置（Optional）
最值
min()最小值（Optional）
max()最大值（Optional）
min(by:)利用给定的方式比较元素，并返回最小元素（Optional）
max(by:)利用给定的方式比较元素，并返回最大元素（Optional）

var array = [(404, "Not Found"), (500, "Internal Server Error"), (403, "Forbidden")]
array.min(by: { a, b in a.0 < b.0}) // Optional((403, "Forbidden"))
array.max(by: { a, b in a.0 < b.0}) // Optional((500, "Internal Server Error"))

添加和删除操作
append(_:)在末尾添加一个元素
append(contentsOf:)在末尾添加多个元素

var numbers = [Int](3 ... 5)
numbers.append(contentsOf: 7 ... 9) //[3, 4, 5, 7, 8, 9]

insert(_:at:)在指定位置入一个元素
insert(contentsOf:at:)在指定位置插入多个元素

var numbers = [Int](3 ... 5)
numbers.insert(2, at: 0) // [2, 3, 4, 5]
numbers.insert(contentsOf: -2 ... 1, at: 0) // [-2, -1, 0, 1, 2, 3, 4, 5]

remove(at:)移除并返回指定位置的一个元素

var numbers = [1, 1, 2, 3, 5, 8, 13]
let num = numbers.remove(1) // 1 [1, 2, 3, 5, 8, 13]

removeFirst()移除并返回第一个元素
removeLast()移除并返回最后一个元素
popLast()移除并返回最后一个元素（Optional），数组为空，则返回nil
removeFirst(:)移除前面多个元素
removeLast(:)移除后面多个元素

var numbers = [Int](5 ... 11)
numbers.removeFirst(3) // [8, 9, 10, 11]
numbers.removeLast(2) // [8, 9]

removeSubrange(_:)移除给定返回的元素
removeAll()移除所有元素
removeAll(keepingCapacity:)移除所有元素，保留数组容量

ArraySlice

ArraySlice是数组或者其他ArraySlice的一段连续切片，和原数组共享内存。
当要改变ArraySlice的时候，ArraySlice会copy出来，形成单独内存。
ArraySlice拥有和Array基本完全类似的方法。

通过Drop得到ArraySlice
dropFirst(:)“移除”原数组前面指定个数的元素，得到一个ArraySlice
dropLast(:)“移除”原数组后指定个数的元素，得到一个ArraySlice
drop(:)“移除”原数组符合指定条件的元素，得到一个ArraySlice
通过prefix得到ArraySlice
prefix(:)获取数组前面指定个数的元素组成的ArraySlice
prefix(upTo:)获取数组到指定位置（不包含指定位置）前面的元素组成的ArraySlice
prefix(through:)获取数组到指定位置（包含指定位置）前面的元素组成的ArraySlice
prefix(where:)获取数组前面符合条件的元素（到第一个不符合条件的元素截止）组成的ArraySlice

var numbers = [5, 2, 10, 1, 0, 100, 46, 99]
numbers.prefix(4) // [5, 2, 10, 1]
numbers.prefix(upTo: 4) // [5, 2, 10, 1]
numbers.prefix(through: 4) // [5, 2, 10, 1, 0]
print(numbers.prefix{ $0 < 10 }) // [5, 2]

通过suffix得到ArraySlice
suffix(:)获取数组后面指定个数的元素组成的ArraySlice
suffix(from:)获取数组从指定位置（包含指定位置）到结尾的元素组成的ArraySlice
通过Range得到ArraySlice
可以通过对数组下标指定Range获取ArraySlice，可以使用闭区间、半开半闭区间、单侧区间
甚至...来获取整个数组组成的ArraySlice

let numbers = [5, 2, 10, 1, 0, 100, 46, 99]
numbers[3...5] // [1, 0, 100]
numbers[3..<5] // [1, 0]
numbers[...2] // [5, 2, 10]
numbers[6...] // [46, 99]
numbers[...] // [5, 2, 10, 1, 0, 100, 46, 99]

ArraySlice转为Array

ArraySlice无法赋值给另一个Array的常量或变量，需要使用Array(slice)

var numbers = [5, 2, 10, 1, 0, 100, 46, 99]
let slice = array[3...5] // [1, 0, 100]
array = Array(slice) // [1, 0, 100]

ArraySlice和原Array是相互独立的，它们添加、删除元素不会影响对方

其他操作

数组的重排
shuffle()在原数组上将数组元素打乱，只能作用在数组变量上。
shuffled()返回原数组的随机化数组，可以作用在变量或常量上。
数组的逆序
reverse()在原数组上将数组逆序，只能作用在数组变量上。
reversed()返回原数组的逆序“集合表示”，可以作用在数组变量或常量上，该方法不会分配新内存空间。
数组的分组
partition(by: (Int) throws -> Bool)将数组以摸个条件分组，数组前半部分都是不符合条件的元素，后半部分都是符合条件的元素。

var numbers = [5, 2, 10, 1, 0, 100, 46, 99]
let index = numbers.partition { (element) -> Bool in
    element > 10
}
let partition1 = numbers[..<index] // [5, 2, 10, 1, 0]
let partition2 = numbers[index...] // [100, 46, 99]

数组的排序
sort()在原数组上将元素排序，只能作用于数组变量。
sorted()返回原数组的排序结果数组，可以作用在数组变量和常量上。
元素交换
swapAt(_:_:)交换指定位置的两个元素