Swift Arrays

Add to favorites

Organize, transform, and display your data with Swift's most essential collection structure

1. Introduction to Arrays

Arrays are one of the most fundamental data structures in Swift programming. They allow you to store ordered collections of items of the same type. Understanding arrays is essential for nearly every app you'll build, as they form the foundation for lists, collections, and many other UI components in SwiftUI.

A. What is an Array?

i. Definition: An array is an ordered collection of values of the same type. In Swift, this type consistency is strictly enforced, meaning you can't mix integers and strings in the same array unless you use a special type that can represent both.

ii. Purpose: Arrays help you organize and manage multiple related values within a single variable. For example, instead of creating separate variables like user1, user2, and user3, you can create a single users array that holds all user data.

iii. Visual representation: Think of an array as a row of boxes, each containing a value, with each box having a numeric position (index). The first box is at position 0, the second at position 1, and so on:

[0]      [1]       [2]        [3]
"Apple"  "Orange"  "Banana"   "Grape"

iv. Memory allocation: Behind the scenes, arrays in Swift typically allocate contiguous memory blocks, which makes access by index very fast (constant time complexity or O(1)).

B. Why Use Arrays?

i. Organization: Keep related values together instead of creating multiple variables. This reduces the number of variable names you need to track and makes your code cleaner and more maintainable.

ii. Iteration: Perform the same operations on multiple values efficiently. Arrays allow you to process many items with a single loop or higher-order function, which is both faster to write and more readable.

iii. Data management: Easily add, remove, or modify collection elements with built-in methods that handle the complexity of memory management for you.

iv. Data-driven interfaces: In SwiftUI, arrays are fundamental for creating dynamic user interfaces where the number of elements might change at runtime (like lists, grids, and other collection views).

v. Algorithm implementation: Many algorithms in computer science rely on arrays as their foundational data structure. Understanding arrays helps you implement sorting, searching, and other common operations.

2. Creating Arrays in Swift

There are several ways to create arrays in Swift, each with different use cases depending on what you're trying to accomplish.

A. Array Literals

i. Using square brackets: The simplest way to create an array is with array literals, which use square brackets containing a comma-separated list of values.

let fruits = ["Apple", "Banana", "Orange"]
let scores = [85, 92, 78, 96]
let mixedTypes = [1, 2, "three"] // Error: Cannot convert value of type 'String' to expected element type 'Int'

Notice that Swift enforces type consistency - the last example would cause a compilation error.

ii. Empty arrays: Creating arrays with no elements is useful when you plan to populate the array later in your code.

// Method 1: Type annotation with empty brackets
let emptyArray: [String] = []

// Method 2: Using initializer syntax
let anotherEmptyArray = [String]()

// Method 3: Array with initial capacity but no elements
var preAllocatedArray = Array<Int>(repeating: 0, count: 10)

The third example creates an array with 10 integers, all initialized to 0, which is useful when you know how many elements you'll need.

B. Array Type Annotation

i. Explicit type declaration: Declaring the type of elements an array will contain using the syntax [ElementType].

let numbers: [Int] = [1, 2, 3, 4, 5]
let optionalNumbers: [Int?] = [1, 2, nil, 4, 5] // Array of optional integers
let matrix: [[Int]] = [[1, 2], [3, 4]] // 2D array (array of arrays)

ii. Type inference: Swift can often determine the array type automatically based on the values you provide, which makes your code more concise.

let colors = ["Red", "Green", "Blue"] // Swift infers [String]
let mixedNumbers = [1, 2.5, 3.14] // Swift infers [Double] and converts integers

iii. Generic array type: Using the full generic syntax for more complex cases.

// These are equivalent:
let shortSyntax: [String] = []
let genericSyntax: Array<String> = []

// This is useful for more complex types:
let arrayOfDictionaries: Array<Dictionary<String, Int>> = []
// Which could also be written as:
let arrayOfDictionaries2: [[String: Int]] = []

iv. Arrays of custom types: Creating arrays of your own defined types.

struct User {
    let id: Int
    let name: String
}

let users: [User] = [
    User(id: 1, name: "Alice"),
    User(id: 2, name: "Bob")
]

3. Accessing Array Elements

Accessing elements is one of the most common operations you'll perform with arrays. Swift provides several ways to retrieve elements safely and efficiently.

A. Using Indices

i. Zero-based indexing: Array indices start at 0, not 1. This is standard across most programming languages but can be confusing for beginners.

let fruits = ["Apple", "Banana", "Orange"]
let firstFruit = fruits[0] // "Apple"
let secondFruit = fruits[1] // "Banana"
let lastFruit = fruits[2] // "Orange"

ii. Index out of bounds: Accessing an invalid index will crash your app at runtime. This is a common source of bugs, so be careful!

// This would cause a crash:
// let crashExample = fruits[10] // Error: Index out of range

iii. Safe access with indices: To safely access elements, always check that the index is valid first.

let index = 5
if index < fruits.count {
    let fruit = fruits[index]
    print("The fruit at index \(index) is \(fruit)")
} else {
    print("Index \(index) is out of bounds")
}

iv. Negative indices: Unlike some languages, Swift doesn't support negative indices. You can't use -1 to access the last element.

// This would cause a compilation error:
// let lastItem = fruits[-1] // Error

v. Computed indices: You can use expressions to compute indices dynamically.

let middleIndex = fruits.count / 2
let middleFruit = fruits[middleIndex]

B. Properties and Methods for Access

Swift provides safer alternatives to direct index access that help prevent crashes and make your code more robust.

i. first and last properties: Safely access the first or last element. These properties return optional values (nil if the array is empty).

let firstItem = fruits.first // Returns optional "Apple"
let lastItem = fruits.last // Returns optional "Orange"

// Safe usage with optional binding
if let first = fruits.first {
    print("The first fruit is \(first)")
}

// Or with nil coalescing for default values
let firstFruit = fruits.first ?? "No fruits available"

ii. Range access: Access multiple consecutive elements using Swift's range operators.

// Closed range: includes both endpoints
let firstTwo = fruits[0...1] // ["Apple", "Banana"]

// Half-open range: excludes the upper bound
let firstTwoAlso = fruits[0..<2] // ["Apple", "Banana"]

// Open-ended ranges
let fromSecondOnward = fruits[1...] // ["Banana", "Orange"]
let upToLast = fruits[..<2] // ["Apple", "Banana"]

iii. indices property: Access the valid range of indices for the array.

for index in fruits.indices {
    print("Fruit at index \(index) is \(fruits[index])")
}

**iv. randomElement(): Get a random element from the array.

if let randomFruit = fruits.randomElement() {
    print("Random selection: \(randomFruit)")
}

v. Accessing with predicates: Find elements based on conditions.

// Find the first element that starts with "A"
let aFruit = fruits.first { $0.starts(with: "A") } // Returns optional "Apple"

// Find all elements that start with "B"
let bFruits = fruits.filter { $0.starts(with: "B") } // ["Banana"]

4. Modifying Arrays

To modify an array in Swift, you must declare it with the var keyword (making it mutable) rather than let (which makes it immutable). Attempting to modify a let array will result in a compilation error.

A. Adding Elements

**i. append(_:): Add an element to the end of the array. This is the most efficient way to add elements since it doesn't require shifting other elements.

var shoppingList = ["Eggs", "Milk"]
shoppingList.append("Flour")
// shoppingList is now ["Eggs", "Milk", "Flour"]

// You can also append multiple elements at once
shoppingList.append(contentsOf: ["Baking Powder", "Salt"])
// shoppingList is now ["Eggs", "Milk", "Flour", "Baking Powder", "Salt"]

**ii. insert(_:at:): Add an element at a specific position. This is less efficient for large arrays as it requires shifting all elements after the insertion point.

shoppingList.insert("Butter", at: 1)
// shoppingList is now ["Eggs", "Butter", "Milk", "Flour", "Baking Powder", "Salt"]

// Be careful not to insert at an index beyond the array's count
// This would crash:
// shoppingList.insert("Invalid", at: 10) // Error if shoppingList.count < 10

**iii. += operator: Append another array. This is a convenient way to combine arrays.

shoppingList += ["Chocolate", "Sugar"]
// shoppingList is now ["Eggs", "Butter", "Milk", "Flour", "Baking Powder", "Salt", "Chocolate", "Sugar"]

// The += operator is equivalent to:
shoppingList.append(contentsOf: ["Vanilla", "Cinnamon"])

iv. Modifying through indices: You can also add elements by creating new arrays with additional elements.

// Creating a new array with added elements (useful for SwiftUI where state updates are important)
let updatedList = shoppingList + ["Apples", "Bananas"]

// Inserting multiple items at a specific position
shoppingList.insert(contentsOf: ["Oil", "Vinegar"], at: 3)

B. Removing Elements

Swift provides multiple ways to remove elements from arrays, depending on what you're trying to accomplish.

**i. remove(at:): Remove an element at a specific index and return the removed value.

let removed = shoppingList.remove(at: 2) // Removes "Milk" and returns it
// shoppingList is now ["Eggs", "Butter", "Flour", "Oil", "Vinegar", "Baking Powder", "Salt", "Chocolate", "Sugar"]
print("Removed \(removed)") // "Removed Milk"

// This method will crash if the index is out of bounds, so always check first:
let indexToRemove = 5
if indexToRemove < shoppingList.count {
    shoppingList.remove(at: indexToRemove)
}

**ii. removeFirst() and removeLast(): Remove from either end of the array and return the removed value.

let firstItem = shoppingList.removeFirst() // Removes "Eggs" and returns it
let lastItem = shoppingList.removeLast() // Removes "Sugar" and returns it

// You can also remove multiple elements:
let firstThree = shoppingList.removeFirst(3) // Removes and returns the first 3 elements
let lastTwo = shoppingList.removeLast(2) // Removes and returns the last 2 elements

// These methods will crash if the array doesn't have enough elements, so for safety:
if !shoppingList.isEmpty {
    let first = shoppingList.removeFirst()
}

**iii. removeAll(): Clear the entire array. This is more efficient than removing items one by one.

shoppingList.removeAll()
// shoppingList is now an empty array

// You can keep capacity allocated for performance reasons:
shoppingList.removeAll(keepingCapacity: true)
// The array is empty but memory is still allocated for quick refilling

iv. filter for conditional removal: Create a new array excluding elements that match certain criteria.

var numbers = [1, 2, 3, 4, 5, 6]
// Remove all even numbers
numbers = numbers.filter { $0 % 2 != 0 }
// numbers is now [1, 3, 5]

**v. removeAll(where:): Remove all elements that satisfy a condition.

var words = ["apple", "banana", "pear", "orange"]
// Remove all words starting with "a"
words.removeAll(where: { $0.starts(with: "a") })
// words is now ["banana", "pear", "orange"]

C. Updating Elements

Updating existing elements in an array is straightforward in Swift, but there are several techniques to be aware of.

i. Changing a value at a specific index: Simply assign a new value to the element at that position.

var names = ["Alice", "Bob", "Charlie"]
names[1] = "Benjamin"
// names is now ["Alice", "Benjamin", "Charlie"]

// Be careful not to use an index that's out of bounds:
// names[5] = "David" // This would crash if names.count <= 5

ii. Replacing a range of values: Update multiple elements at once with a range assignment.

names[0...1] = ["Andrew", "Barbara"]
// names is now ["Andrew", "Barbara", "Charlie"]

// You can replace a range with a different number of elements:
names[0...1] = ["Alex", "Bill", "Beth"]
// names is now ["Alex", "Bill", "Beth", "Charlie"]

iii. Updating using functional methods: Use map to transform all elements.

// Convert all names to uppercase
names = names.map { $0.uppercased() }
// names is now ["ALEX", "BILL", "BETH", "CHARLIE"]

// Conditionally update elements
names = names.map { $0.starts(with: "B") ? $0.lowercased() : $0 }
// Only B-names are now lowercase: ["ALEX", "bill", "beth", "CHARLIE"]

iv. Update with enumerated index: Modify elements based on their position.

var scores = [75, 82, 90, 65]
// Add bonus points to each score based on position
for (index, score) in scores.enumerated() {
    scores[index] = score + index * 2 // More bonus points for later items
}
// scores is now [75, 84, 94, 71]

v. Swap elements: Exchange the positions of two elements.

var fruits = ["Apple", "Banana", "Orange", "Grape"]
fruits.swapAt(0, 2)
// fruits is now ["Orange", "Banana", "Apple", "Grape"]

5. Array Operations and Methods

Swift arrays come with a rich set of built-in operations and methods that make working with collections efficient and expressive.

A. Finding Elements

**i. contains(_:): Check if an element exists in the array. Returns a boolean value.

let fruits = ["Apple", "Banana", "Orange", "Grape"]
let hasApple = fruits.contains("Apple") // true
let hasMango = fruits.contains("Mango") // false

// For arrays of custom types, you need to make your type conform to Equatable
struct Product: Equatable {
    let id: Int
    let name: String
    // Swift automatically synthesizes == for simple structs
}

let products = [Product(id: 1, name: "iPhone"), Product(id: 2, name: "iPad")]
let hasIPhone = products.contains(Product(id: 1, name: "iPhone")) // true

**ii. firstIndex(of:) and lastIndex(of:): Find the position of the first or last occurrence of an element.

let repeatFruits = ["Apple", "Banana", "Apple", "Orange"]

if let index = repeatFruits.firstIndex(of: "Apple") {
    print("First Apple is at position \(index)") // "First Apple is at position 0"
}

if let index = repeatFruits.lastIndex(of: "Apple") {
    print("Last Apple is at position \(index)") // "Last Apple is at position 2"
}

// These methods return nil if the element doesn't exist:
if let index = fruits.firstIndex(of: "Mango") {
    print("Found at \(index)")
} else {
    print("Not found") // This will print
}

iii. Finding with predicates: Find elements that match specific conditions.

// Find first element matching a condition
let firstLongFruit = fruits.first { $0.count > 5 } // "Banana"

// Find index of first element matching a condition
if let index = fruits.firstIndex(where: { $0.starts(with: "O") }) {
    print("First fruit starting with O is at position \(index)") // "First fruit starting with O is at position 2" (Orange)
}

// Check if any element satisfies a condition
let hasShortName = fruits.contains { $0.count < 5 } // true (for "Grape")

// Check if all elements satisfy a condition
let allLowercase = fruits.allSatisfy { $0 == $0.lowercased() } // false

iv. Count occurrences: Count how many elements match a condition.

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let evenCount = numbers.filter { $0 % 2 == 0 }.count // 5

// Or more efficiently:
let oddCount = numbers.reduce(0) { $0 + ($1 % 2 == 1 ? 1 : 0) } // 5

B. Transforming Arrays

Swift provides powerful functional programming methods that help you transform arrays without writing complex loops.

**i. map(_:): Transform each element into something new, creating a new array with the results.

let numbers = [1, 2, 3, 4]
let doubled = numbers.map { $0 * 2 } // [2, 4, 6, 8]

// Convert to strings
let numberStrings = numbers.map { String($0) } // ["1", "2", "3", "4"]

// Transform custom types
struct User {
    let id: Int
    let name: String
}

let users = [User(id: 1, name: "Alice"), User(id: 2, name: "Bob")]
let usernames = users.map { $0.name } // ["Alice", "Bob"]

// Chaining transformations
let squaredThenAddFive = numbers.map { $0 * $0 }.map { $0 + 5 } // [6, 9, 14, 21]

**ii. filter(_:): Keep only elements that pass a test, removing others.

let evenNumbers = numbers.filter { $0 % 2 == 0 } // [2, 4]

// Multiple conditions
let divisibleByTwoOrThree = numbers.filter { $0 % 2 == 0 || $0 % 3 == 0 } // [2, 3, 4]

// Filtering objects
let premiumUsers = users.filter { $0.id > 1 } // [User(id: 2, name: "Bob")]

// Chaining with other operations
let doubledEvens = numbers.filter { $0 % 2 == 0 }.map { $0 * 2 } // [4, 8]

**iii. sorted() and sort(): Arrange elements in order.

let unsortedNumbers = [3, 1, 4, 2]
// Create a new sorted array (immutable operation)
let sortedNumbers = unsortedNumbers.sorted() // [1, 2, 3, 4]

// Sort in place (mutating operation)
var mutableNumbers = [3, 1, 4, 2]
mutableNumbers.sort()
// mutableNumbers is now [1, 2, 3, 4]

// Custom sorting with closures
let descendingNumbers = unsortedNumbers.sorted(by: >) // [4, 3, 2, 1]

// Sorting by a specific property
let sortedByNameLength = users.sorted { $0.name.count < $1.name.count }

**iv. compactMap(_:): Transform and filter nil results in one operation.

let stringNumbers = ["1", "2", "three", "4", "five"]
let parsedNumbers = stringNumbers.compactMap { Int($0) } // [1, 2, 4]
// This eliminates any nil results from the Int conversion

**v. flatMap(_:): Flatten nested arrays and transform elements.

let nestedArrays = [[1, 2], [3, 4], [5]]
let flattened = nestedArrays.flatMap { $0 } // [1, 2, 3, 4, 5]

// Combine with transformation
let flattenedDoubled = nestedArrays.flatMap { array in
    array.map { $0 * 2 }
} // [2, 4, 6, 8, 10]

**vi. reduce(_:_:): Combine all elements into a single value.

let sum = numbers.reduce(0, +) // 10 (0 + 1 + 2 + 3 + 4)
let product = numbers.reduce(1, *) // 24 (1 * 1 * 2 * 3 * 4)

// Custom reduction
let concatenated = ["Hello", "World"].reduce("", { $0 + " " + $1 }).trimmingCharacters(in: .whitespaces)
// "Hello World"

C. Combining Arrays

**i. + operator: Create a new array by joining two arrays.

let firstHalf = [1, 2, 3]
let secondHalf = [4, 5, 6]
let combined = firstHalf + secondHalf // [1, 2, 3, 4, 5, 6]

6. Array Iteration

A. For-In Loops

**i. Looping through all elements.

let animals = ["Dog", "Cat", "Bird"]
for animal in animals {
    print("I have a \(animal)")
}

**ii. Accessing the index with enumerated().

for (index, animal) in animals.enumerated() {
    print("Animal \(index + 1): \(animal)")
}

B. ForEach with Closures

**i. Using higher-order functions for iteration.

animals.forEach { animal in
    print("The \(animal) says hello")
}

7. Multidimensional Arrays

A. Arrays of Arrays

**i. Creating a 2D array (matrix).

let matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

**ii. Accessing elements in a 2D array.

let middleElement = matrix[1][1] // 5

8. Common Array Patterns in SwiftUI

A. Using Arrays with ForEach

**i. Creating views from array data.

struct ContentView: View {
    let fruits = ["Apple", "Banana", "Orange"]

    var body: some View {
        List {
            ForEach(fruits, id: \.self) { fruit in
                Text(fruit)
            }
        }
    }
}

B. Arrays with Identifiable Items

**i. Creating arrays of objects that conform to Identifiable.

struct Task: Identifiable {
    let id = UUID()
    var title: String
    var isCompleted: Bool
}

struct TaskListView: View {
    let tasks = [
        Task(title: "Learn Swift", isCompleted: true),
        Task(title: "Build an app", isCompleted: false)
    ]

    var body: some View {
        List {
            ForEach(tasks) { task in
                Text(task.title)
            }
        }
    }
}

9. Best Practices and Tips

A. Safety Considerations

**i. Always check array bounds before accessing by index. **ii. Use optional binding when accessing elements that might not exist. **iii. Consider using first(where:) instead of finding an index and then accessing it.

B. Performance Tips

**i. Pre-allocate capacity for large arrays when the size is known.

var largeArray = [Int]()
largeArray.reserveCapacity(10000)

**ii. Use value semantics (copying) wisely to avoid unexpected behaviors. **iii. Consider specialized collections for specific use cases (Set for unique elements, Dictionary for key-value pairs).

Conclusion

Arrays are a powerful and versatile tool in Swift programming. They allow you to organize related data, efficiently manipulate collections of values, and form the backbone of many data structures in your apps. By mastering arrays, you're taking a significant step toward becoming proficient in Swift development.

As you continue your Swift journey, you'll discover many more advanced array techniques and patterns, but this foundation will serve you well in most of your programming tasks.

Learn with videos and source files. Available to Pro subscribers only.

Purchase includes access to 50+ courses, 320+ premium tutorials, 300+ hours of videos, source files and certificates.

BACK TO

Swift Collections: Arrays, Sets, and Dictionaries Overview

Download source files

Download the videos and assets to refer and learn offline without interuption.

Design template

Source code for all sections

Video files, ePub and subtitles

Videos

Assets

Building Your iOS Development Foundation

Master the fundamentals of Swift programming with hands-on examples designed for beginners and experienced developers alike

SwiftUI Print Debugging

Print debugging: Unlock the invisible processes with strategic print statements that illuminate state changes, view lifecycles and data flow