第十一章 Swift 数组

Swift 数组是个结构体,并且会强制检测元素的类型，如果类型不同则会报错。
Swift 数组应该遵循像Array<Element>这样的形式，其中Element是这个数组中唯一允许存在的数据类型,如果需要不同类型的元素的数组，请使用Any。
Swift数组可以存储可选类型类型，当元素为可选类型时，其元素可以为nil。

1.创建数组

我们可以使用构造语法来创建一个由特定数据类型构成的空数组：
var someArray = [SomeType]()

初始化数组大小的语法：
var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)

创建类型为 Int ，数量为 3，初始值为 0 的空数组：
var someInts = [Int](repeating: 0, count: 3)

创建三个元素的数组：
var someInts:[Int] = [10, 20, 30]

数组嵌套
var arr = [[[[Double]]]]()

2.访问数组

我们可以根据数组的索引来访问数组的元素，语法如下：
var someVar = someArray[index]

var someInts = [Int](repeating: 10, count: 3)
var someVar = someInts[0]

print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )

// 第一个元素的值 10
// 第二个元素的值 10
// 第三个元素的值 10

3. 修改数组

你可以使用 append()方法或者赋值运算符 += 在数组末尾添加元素，如下所示，我们初始化一个数组，并向其添加元素：

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

var someVar = someInts[0]

print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )
// 第一个元素的值 20
// 第二个元素的值 30
// 第三个元素的值 40

我们也可以通过索引修改数组元素的值：

var someInts = [Int]()

someInts.append(20)
someInts.append(30)
someInts += [40]

// 修改最后一个元素
someInts[2] = 50

var someVar = someInts[0]

print( "第一个元素的值 \(someVar)" )
print( "第二个元素的值 \(someInts[1])" )
print( "第三个元素的值 \(someInts[2])" )

// 第一个元素的值 20
// 第二个元素的值 30
// 第三个元素的值 50

以上程序执行输出结果为：

4. 遍历数组

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

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]

for item in someStrs {
   print(item)
}

// Apple
// Amazon
// Runoob
// Google

如果我们同时需要每个数据项的值和索引值，可以使用 String 的 enumerate() 方法来进行数组遍历。实例如下：

var someStrs = [String]()

someStrs.append("Apple")
someStrs.append("Amazon")
someStrs.append("Runoob")
someStrs += ["Google"]

for (index, item) in someStrs.enumerated() {
    print("在 index = \(index) 位置上的值为 \(item)")
}

// 在 index = 0 位置上的值为 Apple
// 在 index = 1 位置上的值为 Amazon
// 在 index = 2 位置上的值为 Runoob
// 在 index = 3 位置上的值为 Google

5. 合并数组

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

var intsA = [Int](repeating: 2, count:2)
var intsB = [Int](repeating: 1, count:3)

var intsC = intsA + intsB

for item in intsC {
    print(item)
}

/*
2
2
1
1
1
*/

6. count 属性

我们可以使用 count 属性来计算数组元素个数：

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)

var intsC = intsA + intsB

print("intsA 元素个数为 \(intsA.count)")
print("intsB 元素个数为 \(intsB.count)")
print("intsC 元素个数为 \(intsC.count)")

// intsA 元素个数为 2
// intsB 元素个数为 3
// intsC 元素个数为 5

7. isEmpty 属性

我们可以通过只读属性 isEmpty 来判断数组是否为空，返回布尔值：

var intsA = [Int](count:2, repeatedValue: 2)
var intsB = [Int](count:3, repeatedValue: 1)
var intsC = [Int]()

print("intsA.isEmpty = \(intsA.isEmpty)")
print("intsB.isEmpty = \(intsB.isEmpty)")
print("intsC.isEmpty = \(intsC.isEmpty)")

intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true

8. map函数

Swift为数组提供了3类map函数：
filter: 根据回调里的条件将数组过滤后返回一个新数组
map: 将回调返回的元素组成一个新数组
compactMap: 强制解包可选类型，剔除其中nil，返回一个新数组
flatMap: 强制解包可选类型，剔除其中nil，将回调返回的元素组成一个新数组(即map+compactMap,违反了单一职责，故废弃，新增compactMap)

class Person: NSObject {
    let id: String
    let name: String
    
    override var description: String {
        return "id: \(id), name: \(name)"
    }
    
    init(id: String,
         name: String) {
        self.id = id
        self.name = name
    }
}

var arr = [Person]()
arr.append(.init(id: "1", name: "bob"))
arr.append(.init(id: "2", name: "linda"))
arr.append(.init(id: "3", name: "sam"))
arr.append(.init(id: "1", name: "bob2"))

let filter = arr.filter({ $0.id == "1" })
print(filter)
        
let map = arr.map({ $0.name })
print(map)
        
var arr2: [Person?] = arr
arr2[1] = nil
let compactMap = arr2.compactMap({ $0 })
print(compactMap)

let flatMap = arr2.flatMap({ $0?.id })
print(flatMap)

// [id: 1, name: bob, id: 1, name: bob2]
// ["bob", "linda", "sam", "bob2"]
// [id: 1, name: bob, id: 3, name: sam, id: 1, name: bob2]
// ["1", "3", "1"]

9.排序

Swift提供了便捷的排序功能，sorted()是升序，也可以通过sorted(by:)更改排序条件。

let arr = [154,5,456,232]
let arr2 = arr.sorted()
let arr3 = arr.sorted { (itm1, itm2) -> Bool in
    return itm1 > itm2
}
print(arr2)
print(arr3)
// [5, 154, 232, 456]
// [456, 232, 154, 5]

10. 其他

请自行参考注释