数组（Array）

在 Swift 中，Array 是一个常用的数据结构，提供了很多强大的接口（方法和属性）来管理、操作和查询数组。以下是常用接口的分类和对应的说明，涵盖 remove, first 等常见的操作以及其它你可能感兴趣的功能。

1. 数组基本信息 #

属性或方法	功能说明	示例
`first`	返回数组的第一个元素（可选类型，如果数组为空则返回 `nil`）。	`let firstItem = array.first`
`last`	返回数组的最后一个元素（可选类型，如果数组为空则返回 `nil`）。	`let lastItem = array.last`
`count`	返回数组中元素的数量。	`print(array.count)`
`isEmpty`	返回一个布尔值，指示数组是否为空。	`if array.isEmpty { print("Empty") }`

2. 元素的添加 #

方法名称	功能说明	示例
`append(_:)`	在数组末尾追加一个元素。	`array.append(5)`
`insert(_:at:)`	在指定位置插入一个元素，其他元素会向后移动。	`array.insert(2, at: 1)`
`append(contentsOf:)`	将一个数组的内容追加到当前数组中。	`array.append(contentsOf: [3, 4, 5])`

3. 元素的移除 #

方法名称	功能说明	示例
`remove(at:)`	移除指定索引位置的元素，并返回该元素。如果索引越界会崩溃。	`array.remove(at: 2)`
`removeFirst()`	移除数组的第一个元素，如果为空则崩溃。	`array.removeFirst()`
`removeLast()`	移除数组的最后一个元素，如果为空则崩溃。	`array.removeLast()`
`removeFirst(_:)`	从头部开始移除指定数量的元素，数组必须包含足够多的元素。	`array.removeFirst(2)`
`removeLast(_:)`	从尾部开始移除指定数量的元素，数组必须包含足够多的元素。	`array.removeLast(1)`
`removeAll()`	移除所有元素，保持数组为空。	`array.removeAll()`
`removeAll(where:)`	移除满足条件的所有元素。	`array.removeAll(where: { $0 > 3 })`
`popLast()`	移除并返回最后一个元素。如果数组为空，则返回 `nil`。	`let lastItem = array.popLast()`

4. 元素访问 #

方法名称	功能说明	示例
`subscript(_:)`	通过索引获取或设置指定位置的元素，索引越界会崩溃。	`let item = array[1]; array[1] = 10`
`first(where:)`	返回第一个满足条件的元素（可选类型），没有则返回 `nil`。	`let item = array.first(where: { $0 > 3 })`
`last(where:)`	返回最后一个满足条件的元素（可选类型），没有则返回 `nil`。	`let item = array.last(where: { $0 < 5 })`
`contains(_:)`	检查数组是否包含指定的元素。	`if array.contains(2) { print("Found") }`
`contains(where:)`	检查数组是否有任何元素满足条件。	`let result = array.contains(where: { $0 > 0 })`
`index(of:)`	获取指定元素的第一个索引（可选类型），找不到返回 `nil`。	`let index = array.index(of: 3)`
`index(where:)`	获取满足条件的第一个索引（可选类型），找不到返回 `nil`。	`let index = array.index(where: { $0 > 5 })`

5. 数组变换 #

方法名称	功能说明	示例
`map(_:)`	将数组中的每个元素通过闭包转换生成一个新的数组。	`let result = array.map { $0 * 2 }`
`filter(_:)`	通过闭包过滤数组，生成仅包含满足条件的元素的新数组。	`let result = array.filter { $0 > 2 }`
`reduce(_:_:)`	将数组的所有元素组合计算成一个值。	`let sum = array.reduce(0) { $0 + $1 }`
`compactMap(_:)`	转换数组元素并剔除 `nil` 值，生成新数组。	`let result = array.compactMap { Int($0) }`
`flatMap(_:)`	将嵌套数组展平为单层数组并转换。	`let result = array.flatMap { $0 }`

6. 排序与重排 #

方法名称	功能说明	示例
`sorted()`	返回升序排序的新数组（要求数组元素遵循 `Comparable` 协议）。	`let result = array.sorted()`
`sorted(by:)`	返回使用指定闭包条件排序的新数组。	`let result = array.sorted(by: >)`
`sort()`	原地对数组排序，修改自身，按升序排列。	`array.sort()`
`sort(by:)`	原地对数组按指定闭包条件排序，修改自身。	`array.sort(by: >)`
`reverse()`	将数组顺序倒置，修改自身。	`array.reverse()`
`shuffled()`	返回数组的随机排列版本的新数组。	`let result = array.shuffled()`
`shuffle()`	原地将数组随机排列，修改自身。	`array.shuffle()`

7. 分组与分割 #

方法名称	功能说明	示例
`prefix(_:)`	获取从数组前面开始指定数量的元素。	`let firstTwo = array.prefix(2)`
`suffix(_:)`	获取从数组后面开始指定数量的元素。	`let lastTwo = array.suffix(2)`
`split(separator:)`	根据指定值分割数组，返回一个子数组集合。	`let parts = array.split(separator: 3)`
`chunked(by:)` (扩展)	将数组按指定大小分割成更小子数组的集合。 (需要手动实现)	`let chunks = array.chunked(by: 3)`

8. 集合操作 #

方法名称	功能说明	示例
`union(_:)` (Set类型)	返回两个集合的并集（去重）。	`let result = array.union(otherArray)`
`intersection(_:)` (Set)	返回两个集合的交集。	`let result = array.intersection(otherArray)`
`difference(_:)` (Set)	返回当前集合的差集。	`let result = array.subtracting(otherArray)`

9. 类型检查 #

方法名称	功能说明	示例
`allSatisfy(_:)`	检查数组中的所有元素是否满足条件。	`let result = array.allSatisfy { $0 > 0 }`
`contains(where:)`	检查数组中是否有一个元素满足特定条件。	`let result = array.contains(where: { $0 > 3 })`

10. Equatable & Hashable 支持 #

如果数组的元素符合 Equatable 协议，支持以下接口：

方法名称	功能说明	示例
`==`	检查两个数组内容是否相等。	`if array1 == array2 { print("Equal") }`
`index(of:)`	获取指定元素的索引位置，如果不存在则返回 `nil`。	`let idx = array.index(of: 5)`

常用示例操作 #

Swift 中的数组（Array）是一种有序的集合，用于存储同一类型的值。数组本身是值类型，但 Swift 采用“写时复制”优化，因此传递和修改数组时性能表现非常高效。下面我们详细介绍 Swift 数组的基本使用方法和常见操作，并附上代码示例：

1. 数组的创建 #

1.1 创建空数组 #

可以使用类型推断或显式声明类型来创建空数组：

var numbers = [Int]()          // 空的 Int 数组，类型推断为 [Int]
var names: [String] = []       // 显式声明空的 String 数组

1.2 创建并初始化数组 #

直接用字面量初始化数组：

let fruits = ["Apple", "Banana", "Orange"]
let scores: [Double] = [95.5, 88.0, 76.5]

2. 访问数组元素 #

2.1 通过下标访问 #

数组的索引从 0 开始，可以通过下标来读取或修改元素：

var fruits = ["Apple", "Banana", "Orange"]
print(fruits[0])      // 输出 "Apple"

fruits[1] = "Grape"
print(fruits)         // ["Apple", "Grape", "Orange"]

2.2 安全访问 #

使用 first、last 属性或可选下标防止数组越界：

if let firstFruit = fruits.first {
    print("第一个水果：\(firstFruit)")
}

3. 修改数组 #

3.1 添加元素 #

使用 append 方法或 += 运算符来添加元素：

var numbers = [1, 2, 3]
numbers.append(4)         // [1, 2, 3, 4]
numbers += [5, 6]         // [1, 2, 3, 4, 5, 6]

3.2 插入元素 #

使用 insert(_:at:) 在指定位置插入元素：

numbers.insert(0, at: 0)   // 在数组开头插入 0 -> [0, 1, 2, 3, 4, 5, 6]

3.3 删除元素 #

常用方法包括 remove(at:)、removeFirst()、removeLast() 和 removeAll()：

let removed = numbers.remove(at: 3)  // 移除索引 3 的元素，返回被移除的值
numbers.removeFirst()                 // 移除第一个元素
numbers.removeLast()                  // 移除最后一个元素

4. 遍历数组 #

4.1 for-in 循环 #

for fruit in fruits {
    print(fruit)
}

4.2 使用 enumerated() 获取索引和值 #

for (index, fruit) in fruits.enumerated() {
    print("索引 \(index): \(fruit)")
}

5. 数组的其他常用功能 #

判断是否为空：isEmpty 属性
获取元素个数：count 属性
查找元素：contains(_:) 方法或 firstIndex(of:) 方法
排序：使用 sorted() 或 sort() 方法

if !fruits.isEmpty {
    print("水果总数：\(fruits.count)")
}

if fruits.contains("Apple") {
    print("数组中包含 Apple")
}

if let index = fruits.firstIndex(of: "Orange") {
    print("Orange 的索引是 \(index)")
}

let sortedFruits = fruits.sorted()

6. 值类型与写时复制（Copy-on-Write） #

虽然数组是值类型，但 Swift 使用写时复制机制，使得当你将数组赋值给另一个变量或传递到函数中时，只有在修改时才会真正复制数据，从而保持高效性。

7. 其他示例 #

移除重复元素
```
let uniqueArray = Array(Set(array))
```
合并数组
```
let mergedArray = array1 + array2
```

按条件分割数组（Chunk）

extension Array {
    func chunked(by size: Int) -> [[Element]] {
        stride(from: 0, to: count, by: size).map {
            Array(self[$0..<Swift.min($0 + size, count)])
        }
    }
}
let chunks = array.chunked(by: 3)

总结 #

Array 提供了对数组增删改查的丰富接口，常用的有：

元素操作（添加/删除/访问）： append, remove, insert, first, last, subscript。
查询与条件检查： contains, first(where:), filter, allSatisfy 等。
数组操作： map, reduce, compactMap。
排序与遍历函数： sorted, sort, reverse, shuffled。