Swift Programming 101: Advanced Collections

Advanced collections in Swift—arrays, dictionaries, sets, and their functional counterparts—are the backbone of efficient, expressive code. This article explains what they are, how they work under the hood, and how to choose the right one for your data, with concrete examples and common pitfalls.

Background: From Basic to Advanced

Swift’s standard library provides three primary collection types: Array (ordered, indexable), Dictionary (key-value pairs), and Set (unordered, unique elements). Most beginners learn to create and mutate them, but “advanced” usage involves understanding their performance characteristics, leveraging functional methods like map and filter, and using features like Collection protocols, slices, and lazy evaluation. These tools let you write code that is both more concise and more efficient, especially when dealing with large datasets.

How Advanced Collections Work

Under the hood, Swift collections are value types with copy-on-write optimization. When you assign an array to a new variable, it doesn’t copy the elements immediately; it shares the storage until you mutate one of the copies, at which point it performs a deep copy. This makes passing collections around cheap and safe.

Key advanced operations include:

Functional methods: map, filter, reduce, flatMap, and compactMap allow you to transform, select, and combine data without explicit loops.
Subscripts and slices: array[1..<3] returns an ArraySlice, a view into the original array that avoids copying.
Dictionary merging: merge(_:uniquingKeysWith:) combines two dictionaries, resolving conflicts with a closure.
Set operations: union, intersection, subtracting, and symmetricDifference perform mathematical set operations.

For example, to get the squares of even numbers from 0 to 10:

let squares = (0...10).filter { $0 % 2 == 0 }.map { $0 * $0 }
// [0, 4, 16, 36, 64, 100]

Choosing the Right Collection

Each collection type excels in different scenarios:

Array: Use when order matters, you need random access by index, or you have duplicate values.
Set: Use when uniqueness is required and order is irrelevant, and you need fast membership checks (contains is O(1)).
Dictionary: Use when you need to associate keys with values and perform fast lookups by key.
Functional chaining: Use when you need to transform or filter data; it’s often more readable than nested loops.

For example, if you’re tracking unique visitor IDs, a Set is ideal. If you need to store scores by player name, a Dictionary is better.

Common Problems and How to Avoid Them

Even experienced developers hit these pitfalls:

Mutating while iterating: Trying to remove elements from an array while using for-in causes a runtime error. Use removeAll(where:) or filter instead.
Forgetting that dictionary keys must be Hashable: If you use a custom struct as a key, you must conform to Hashable.
Overusing force unwrapping: Accessing a dictionary with dict[key]! crashes if the key doesn’t exist. Use if let value = dict[key] or provide a default with dict[key, default: 0].
Performance traps with contains on arrays: array.contains is O(n), which is fine for small arrays but slow for large ones. If you need frequent membership checks, use a Set.

Performance and Memory

Understanding complexity helps you write efficient code:

Array: Access by index is O(1); insertion at the end is amortized O(1); insertion at the front is O(n).
Dictionary: Lookup, insert, and delete are typically O(1) on average, but degrade to O(n) in worst-case hash collisions.
Set: Same as dictionary for membership operations.
Slices: They share memory with the original array, so creating many slices can keep large buffers alive longer than expected. If you need a standalone copy, use Array(slice).

For large data, consider lazy collections: array.lazy.map { ... } defers computation until the result is needed, which can save time and memory if you only use a few elements.

Alternatives to Standard Collections

Swift’s standard library isn’t the only option. For specialized needs, you can use:

ContiguousArray: A variant of Array that always uses contiguous storage, which can be faster for large arrays of class types.
NSArray / NSDictionary: When bridging to Objective-C or using older APIs, these are reference types and can be mutable or immutable.
Third-party data structures: Libraries like Swift Collections provide Deque, OrderedSet, and OrderedDictionary with different performance trade-offs.

For most apps, the standard collections are sufficient. The alternatives are worth exploring when you have specific performance bottlenecks or ordering requirements.

Frequently Asked Questions

What is the difference between `map` and `flatMap`?

map applies a transformation to each element and returns an array of the same dimension. flatMap (now compactMap for optionals) flattens the result: if the transformation returns an array, flatMap concatenates them into a single array, and if it returns an optional, it removes nils.

When should I use a set instead of an array?

Use a set when you need to ensure all elements are unique and you don’t care about order. Sets also provide O(1) membership checks, which is much faster than an array’s O(n) for large collections.

How do I sort a dictionary by key or value?

Dictionaries are unordered, so you can’t sort them in place. Instead, get an array of key-value pairs and sort that: dict.sorted { $0.key < $1.key } returns an array of tuples sorted by key. For values, compare $0.value.

What is copy-on-write and why does it matter?

Copy-on-write is an optimization where Swift collections share storage until a mutation occurs. This makes passing collections cheap because no immediate copy is made. It matters because it gives you value semantics (each variable has its own independent data) without the performance cost of copying large arrays every time you assign them.

Can I use a custom struct as a dictionary key?

Yes, but the struct must conform to Hashable. You can implement hash(into:) and == manually, or let Swift synthesize them if all stored properties are Hashable.

Why does `array[0..<2]` return a slice, not an array?

Because a slice is a lightweight view into the original array’s memory, avoiding a copy. This is efficient, but slices keep the entire original array alive. If you need a standalone array, use Array(array[0..<2]).

Method: the standard formula for this calculation, rounded as each result states. See how the calculators work or report an error.

More cards in this drawer

The whole Numbers and Powers drawer →