Swift By Rahul
June 28, 2026 · 7 min read ·

Swift Collections and Performance Tips

As Swift developers, we interact with collections constantly. Array, Dictionary, and Set are the workhorses of almost every application, from managing lists of data in a SwiftUI view to parsing complex JSON responses. While these collections are incredibly powerful and convenient, a deep understanding of their underlying characteristics and performance implications is crucial for writing efficient, high-performance Swift code.

Ignoring how these collections behave under the hood can lead to subtle performance bottlenecks, especially when dealing with large datasets or high-frequency operations. In this article, we'll dive into the core Swift collections, explore their performance characteristics, and uncover practical tips to help you build faster and more responsive iOS, macOS, and watchOS applications.

Swift's Primary Collections Array Ordered, Indexed Value Semantics Dictionary Unordered, Key-Value Hashable Keys Set Unordered, Unique Values Hashable Values Swift's Core Collections

Understanding Core Collections and Their Performance

Swift's standard library collections are implemented as structs, meaning they have value semantics. When you assign or pass a collection, a copy is made. However, Swift employs "copy-on-write" optimization, which defers the actual copying until the collection is mutated. This is a significant performance feature, but it's essential to be aware of when a copy might genuinely occur.

Array

Array is an ordered, random-access collection of elements of the same type. It's backed by a contiguous block of memory, making element access by index extremely fast.

  • Accessing Elements (by index): O(1) – Constant time. Accessing myArray[0] or myArray[999] takes roughly the same amount of time.
  • Appending Elements: O(1) (amortized) – On average, appending is very fast. When an array's underlying storage runs out of capacity, it must reallocate a larger block of memory and copy its existing elements. This operation is O(N), but it happens infrequently, leading to an amortized O(1) average.
  • Inserting/Removing Elements (not at end): O(N) – Linear time. If you insert or remove an element in the middle of a large array, all subsequent elements must be shifted. This can be very costly.
  • Removing Elements (from end): O(1) – Removing the last element is fast as no other elements need to be shifted.
var numbers = [1, 2, 3, 4, 5]

// O(1) access
let first = numbers[0] // Fast
let last = numbers[4]  // Fast

// O(1) amortized append
numbers.append(6) // Usually fast

// O(N) insertion in the middle
numbers.insert(100, at: 2) // [1, 2, 100, 3, 4, 5, 6] - Slower for large arrays

// O(N) removal from the middle
numbers.remove(at: 3) // [1, 2, 100, 4, 5, 6] - Slower for large arrays

// O(1) removal from the end
numbers.removeLast() // [1, 2, 100, 4, 5] - Fast

Dictionary

Dictionary is an unordered collection that stores associations between keys and values. Keys must conform to the Hashable protocol, ensuring quick lookups. Dictionaries use a hash table internally.

  • Accessing/Inserting/Removing Elements (by key): O(1) (average) – On average, these operations are constant time. The actual performance depends on the quality of the hash function and the number of hash collisions. In worst-case scenarios (many collisions), it can degrade to O(N).
  • Iterating: O(N) – Iterating through all key-value pairs takes linear time relative to the number of elements.
var userScores: [String: Int] = [
    "Alice": 85,
    "Bob": 92,
    "Charlie": 78
]

// O(1) average access
let bobScore = userScores["Bob"] // Fast

// O(1) average insertion/update
userScores["David"] = 95 // Fast
userScores["Alice"] = 88 // Fast

// O(1) average removal
userScores["Charlie"] = nil // Fast

Set

Set is an unordered collection of unique elements. Like Dictionary keys, elements in a Set must conform to the Hashable protocol. Sets are highly optimized for checking element existence and performing set operations (union, intersection, etc.).

  • Inserting/Removing Elements: O(1) (average) – Similar to Dictionary, insertion and removal are typically constant time.
  • Checking Element Existence: O(1) (average) – Very fast for determining if an element is present.
  • Set Operations (union, intersection, etc.): Typically O(N) where N is the number of elements in the smaller set, or O(M+N) for operations like union, depending on the specific operation.
var uniqueIDs: Set<Int> = [101, 203, 305]

// O(1) average insertion
uniqueIDs.insert(407) // Fast

// O(1) average checking existence
let contains203 = uniqueIDs.contains(203) // Fast (true)
let contains999 = uniqueIDs.contains(999) // Fast (false)

// O(1) average removal
uniqueIDs.remove(101) // Fast

Performance Tips and Best Practices

Now that we understand the basics, let's explore practical ways to leverage this knowledge for better performance.

1. Pre-sizing Collections with reserveCapacity

For Array and Dictionary, frequent reallocations due to growing capacity can be a significant performance hit. If you know roughly how many elements a collection will hold, use reserveCapacity(minimumCapacity:) to pre-allocate memory.

let numberOfItems = 10_000

// Bad: Frequent reallocations
var itemsWithoutCapacity: [Int] = []
for i in 0..<numberOfItems {
    itemsWithoutCapacity.append(i)
}

// Good: Single allocation, much faster
var itemsWithCapacity: [Int] = []
itemsWithCapacity.reserveCapacity(numberOfItems) // Pre-allocate memory
for i in 0..<numberOfItems {
    itemsWithCapacity.append(i)
}

The difference in performance can be substantial:

┌───────────────────────────────────┐     ┌───────────────────────────────────┐
│ Array without reserveCapacity     │     │ Array with reserveCapacity        │
│ (Many small reallocations)        │     │ (Single large allocation)         │
│                                   │     │                                   │
│ [ ] -> [ ]                        │     │ [ ] -> [_,_,_,...,_]              │
│ [1] -> [1,_]                      │     │ [1] -> [1,_,_,...,_]              │
│ [1,2] -> [1,2,_,_]                │     │ [1,2] -> [1,2,_,...,_]            │
│ [1,2,3] -> [1,2,3,_,_,_,_]        │     │ [1,2,3] -> [1,2,3,_,...,_]        │
│ ...                               │     │ ...                               │
│ [1..N] -> [1..N] (Final size)     │     │ [1..N] -> [1..N] (Final size)     │
└───────────────────────────────────┘     └───────────────────────────────────┘
               Slower                              Much Faster

2. Avoiding Unnecessary Copies with ArraySlice

When you take a slice of an Array, Swift's ArraySlice creates a view into the original array's storage rather than making a full copy. This is incredibly efficient, especially for large arrays. The copy only occurs if you mutate the ArraySlice or convert it back to a new Array.

let largeArray = Array(0..<1_000_000)

// This creates a new Array, copying 100,000 elements. Potentially slow.
let subArray = Array(largeArray[10_000..<110_000])

// This creates an ArraySlice, a view into the original array. Very fast.
let subSlice = largeArray[10_000..<110_000]

// You can iterate over an ArraySlice just like an Array
for element in subSlice {
    // ...
}

// If you need a mutable, independent array later, convert it
let newIndependentArray = Array(subSlice) // Copy happens here

3. Choosing the Right Collection for the Job

This is arguably the most crucial performance tip. The right tool for the job makes all the difference.

  • Array: Use when you need ordered elements, access by index, and frequent appends/removals from the end. Avoid frequent insertions/removals from the middle.
  • Dictionary: Use when you need to store key-value pairs and require fast lookups, insertions, or deletions based on a key. Keys must be Hashable.
  • Set: Use when you need to store unique elements and perform fast checks for existence or set operations (union, intersection, subtraction). Elements must be Hashable.

4. Leveraging lazy for Efficient Sequence Transformations

When chaining multiple transformations on a sequence (like map, filter, sorted), Swift normally creates a new intermediate array for each operation. The lazy property allows you to defer computation until it's actually needed, avoiding the creation of these intermediate collections.

let numbers = 1...1_000_000

// Eager evaluation: Each operation creates a new array
let eagerResult = numbers
    .filter { $0 % 2 == 0 } // Creates an array of even numbers
    .map { $0 * 2 }         // Creates another array with doubled evens
    .prefix(10)             // Creates yet another array with the first 10

// Lazy evaluation: Operations are only performed when elements are requested
let lazyResult = numbers.lazy
    .filter { $0 % 2 == 0 }
    .map { $0 * 2 }
    .prefix(10)

// Actual computation happens here, only for the first 10 elements
for number in lazyResult {
    print(number)
    // Output: 4, 8, 12, 16, 20, 24, 28, 32, 36, 40
}

lazy can offer significant performance benefits, especially when you apply many transformations but only consume a small portion of the final result, or when dealing with infinitely long sequences.

5. Measuring Performance

Don't guess, measure! For critical sections of your code, use tools to profile and quantify performance.

  • CFAbsoluteTimeGetCurrent() (for quick local tests): `swift let start = CFAbsoluteTimeGetCurrent() // Your code to measure let end = CFAbsoluteTimeGetCurrent() print("Time elapsed: (end - start) seconds") `
  • Xcode Instruments (for detailed analysis): Use the Time Profiler instrument to identify CPU hotspots and the Allocations instrument to track memory usage, which can reveal hidden copies or excessive reallocations.
  • os_signpost (for custom logging in Instruments): Allows you to mark specific regions of your code in Instruments for precise timing and visualization.
Choosing the Right Swift Collection What kind of data do you have? Do you need ordered elements or access by index? Yes Use Array No Need fast lookup by key? Yes Use Dictionary No Use Set

Summary

Optimizing Swift collections is less about micro-optimizations and more about making informed architectural decisions. By understanding the performance characteristics of Array, Dictionary, and Set, and applying techniques like pre-sizing, using ArraySlice, and lazy evaluation, you can write more efficient and scalable Swift applications. Always remember that the "best" collection or technique depends entirely on your specific use case, so choose wisely and measure when in doubt.

Happy Swifting!

Tagged: