1
2
3
4
5
6
7
8

let literal = [1, 2, 3]
let typed: [Int] = []
let repeated = Array(repeating: 0, count: 5)
let fromRange = Array(1...5)
let empty = [String]()

print(repeated, fromRange)
// prints: [0, 0, 0, 0, 0] [1, 2, 3, 4, 5]

1
2
3
4
5
6

var nums = [3, 1, 4, 1, 5]
nums.append(9)
nums.insert(0, at: 0)
nums.remove(at: 0)
print(nums)
// prints: [3, 1, 4, 1, 5, 9]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

// 从 (键, 值) 序列一次性建字典
let pairs = [("a", 1), ("b", 2)]
print(Dictionary(uniqueKeysWithValues: pairs).keys.sorted())
// prints: ["a", "b"]

print(Dictionary(uniqueKeysWithValues: zip(1..., ["a", "b"]))[2] ?? "?")
// prints: b

// 键可能重复时，得自己定"留谁"的规则
let dup = [("a", 1), ("a", 2)]
print(Dictionary(dup, uniquingKeysWith: { first, _ in first })["a"] ?? -1)
// prints: 1

var arr = [1, 2, 3]
arr.removeAll(keepingCapacity: true)      // 清空元素，但留着已分配的内存
print(arr.isEmpty, arr.capacity >= 3)
// prints: true true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

let nums = [3, 1, 4, 1, 5]

print(nums.sorted())
// prints: [1, 1, 3, 4, 5]
print(nums.sorted(by: >))
// prints: [5, 4, 3, 1, 1]
print(nums.reversed().map { $0 })
// prints: [5, 1, 4, 1, 3]

var mutable = nums
mutable.sort()          // 原地排序，要求元素可比较
print(mutable)
// prints: [1, 1, 3, 4, 5]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

struct Player { let first: String; let last: String }

// 已经按姓氏排好
var roster = [
    Player(first: "Sam", last: "Coffey"),
    Player(first: "Ashley", last: "Hatch"),
    Player(first: "Kristie", last: "Mewis"),
    Player(first: "Ashley", last: "Sanchez"),
]

roster.sort { $0.first < $1.first }      // 再按名字排
print(roster.map(\.last))
// prints: ["Hatch", "Sanchez", "Mewis", "Coffey"]
// 两个 Ashley 的先后没变：Hatch 还在 Sanchez 前面

1
2
3
4
5
6

let nums = [3, 1, 4, 1, 5, 9]

print(nums.prefix(2), nums.suffix(2))
// prints: [3, 1] [5, 9]
print(nums.dropFirst(2), nums.dropLast(2))
// prints: [4, 1, 5, 9] [3, 1, 4, 1]

1
2
3
4
5
6
7

let nums = [3, 1, 4, 1, 5, 9]

let slice = nums[2...4]
print(slice[0])
// 🛑 崩溃：下标越界
print(slice[slice.startIndex])
// prints: 4        ✅ 必须用切片的 startIndex

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var ages = ["Alice": 30, "Bob": 25]

ages["Carol"] = 28                 // 新增
ages["Alice"] = 31                 // 覆盖
ages["Bob"] = nil                  // 删除
print(ages.keys.sorted())
// prints: ["Alice", "Carol"]

print(ages["nobody", default: 0])
// prints: 0

ages["Dave", default: 0] += 1      // 不存在就先用默认值起手
print(ages["Dave"] ?? -1)
// prints: 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

let words = ["apple", "avocado", "banana", "blueberry", "cherry"]
let grouped = Dictionary(grouping: words) { $0.first! }
print(grouped["a"] ?? [])
// prints: ["apple", "avocado"]

let counts = words.reduce(into: [Character: Int]()) { result, word in
    result[word.first!, default: 0] += 1
}
print(counts["b"] ?? 0)
// prints: 2

1
2
3
4
5
6
7

var seen: Set<Int> = [1, 2, 3]
seen.insert(4)
seen.insert(4)                 // 重复插入无效果
print(seen.count)
// prints: 4
print(seen.contains(3))
// prints: true

1
2
3
4
5
6
7

let a: Set = [1, 2, 3, 4]
print(a.union([5, 6]).sorted())
// prints: [1, 2, 3, 4, 5, 6]
print(a.subtracting([1, 2]).sorted())
// prints: [3, 4]
print(a.symmetricDifference([3, 9]).sorted())
// prints: [1, 2, 4, 9]

1
2
3
4
5
6
7
8

var buffer: InlineArray<3, Int> = [1, 2, 3]
buffer[0] = 9
print(buffer.count, buffer[0])
// prints: 3 9

let numbers = [10, 20, 30]
print(numbers.span[1], numbers.span.count)     // 借出来看一眼，不复制
// prints: 20 3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

let pair = (name: "Alice", age: 30)
print(pair.name, pair.1)
// prints: Alice 30

let (n, a) = pair          // 解构
print(n, a)
// prints: Alice 30

let (_, onlyAge) = pair    // 用 _ 忽略不需要的部分
print(onlyAge)
// prints: 30

1
2
3
4

print((1, "b") < (2, "a"))
// prints: true
print((1, 2) < (1, 3))
// prints: true

1
2
3
4
5
6
7
8

print(Array(1...5))
// prints: [1, 2, 3, 4, 5]
print((1...5).map { $0 * $0 })
// prints: [1, 4, 9, 16, 25]
print(Array(stride(from: 0, to: 10, by: 3)))
// prints: [0, 3, 6, 9]
print(Array((1...5).reversed()))
// prints: [5, 4, 3, 2, 1]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// sequence(first:next:)：从第一个值开始，靠闭包推出下一个；返回 nil 就结束
let powers = sequence(first: 1, next: { $0 < 100 ? $0 * 2 : nil })
print(Array(powers))
// prints: [1, 2, 4, 8, 16, 32, 64, 128]

// sequence(state:next:)：状态自带，适合递推
let fib = sequence(state: (0, 1)) { (pair: inout (Int, Int)) -> Int? in
    defer { pair = (pair.1, pair.0 + pair.1) }
    return pair.0
}
print(Array(fib.prefix(7)))
// prints: [0, 1, 1, 2, 3, 5, 8]

print(Array(repeatElement("x", count: 3)))
// prints: ["x", "x", "x"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

struct Countdown: Sequence, IteratorProtocol {
    var current: Int

    mutating func next() -> Int? {
        guard current > 0 else { return nil }   // 返回 nil 表示"没有了"
        defer { current -= 1 }
        return current
    }
}

print(Array(Countdown(current: 3)))
// prints: [3, 2, 1]
print(Countdown(current: 4).map { $0 * 10 })
// prints: [40, 30, 20, 10]
for x in Countdown(current: 2) { print(x) }
// prints:
//   2
//   1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

var i = 0
let counter = AnyIterator { () -> Int? in
    i += 1
    return i <= 3 ? i : nil
}
print(Array(counter))
// prints: [1, 2, 3]

// 承接上文：Countdown 已定义
let seq = AnySequence(Countdown(current: 3))
print(seq.reduce(0, +))
// prints: 6

1
2
3

let s = [1, 2, 3].lazy.map { $0 * 2 }
print(s.first ?? 0)
// prints: 2