When you start learning Swift, you first work with individual values.

For example:

let name = "Alex"
let age = 25
let isDeveloper = true

But real applications rarely work with only one value at a time.

An eCommerce app may have hundreds of products. A social media app may contain thousands of usernames. A settings screen may store multiple preferences. A weather application may keep temperatures for different cities.

Creating a separate variable for every value would quickly become impractical.

Swift solves this problem with collections.

The three primary collection types you should understand are:

Array
Set
Dictionary

They all store multiple values, but they are designed for different situations.

In this complete guide, you will learn what Swift arrays, sets, and dictionaries are, how they differ, how to create and modify them, how to loop through collections, and when you should use each one.

What Are Collections in Swift?

A collection is a data structure that stores multiple values together.

Instead of:

let language1 = "Swift"
let language2 = "Kotlin"
let language3 = "Dart"
let language4 = "Java"

you can create one collection:

let languages = ["Swift", "Kotlin", "Dart", "Java"]

Now all four values belong to one array.

Swift provides three important collection types:

Swift Collections
       │
       ├── Array
       │
       ├── Set
       │
       └── Dictionary

Each has a different purpose.

Swift Array vs Set vs Dictionary

Before learning each collection in detail, understand the main difference.

Collection	Stores	Ordered?	Duplicates?	Access
Array	Values	Yes	Yes	Index
Set	Unique values	No defined ordering	No	Membership/value
Dictionary	Key-value pairs	No defined ordering	Keys unique	Key

For example:

Array

["Swift", "Kotlin", "Dart"]

Set

Set(["Swift", "Kotlin", "Dart"])

Dictionary

[
    "name": "Alex",
    "city": "Jaipur"
]

The right collection depends on how you need to store and access your data.

What Is an Array in Swift?

An Array stores multiple values of the same type in an ordered collection.

Example:

let languages = ["Swift", "Kotlin", "Dart"]

The values maintain their position.

Conceptually:

Index     Value

0         Swift
1         Kotlin
2         Dart

Swift arrays use zero-based indexing.

That means the first element is at index:

not:

Creating an Array in Swift

Swift can usually infer the type automatically.

let fruits = ["Apple", "Mango", "Banana"]

Swift understands this as an array of strings.

Its type is:

[String]

You can also explicitly declare the type:

let fruits: [String] = ["Apple", "Mango", "Banana"]

Both are valid.

Creating an Array of Integers

let numbers = [10, 20, 30, 40]

The inferred type is:

[Int]

Explicit version:

let numbers: [Int] = [10, 20, 30, 40]

Creating an Empty Array

There are several ways to create an empty array.

var names: [String] = []

Or:

var names = [String]()

Now:

names.append("Alex")

The array becomes:

["Alex"]

Why Does an Empty Array Need a Type?

Consider:

var items = []

Swift does not have enough information to determine what kind of values the collection should contain.

Instead, specify the type:

var items: [String] = []

Now Swift knows that items stores strings.

Array with Repeated Values

You can create an array containing repeated values:

let numbers = Array(repeating: 0, count: 5)

Result:

[0, 0, 0, 0, 0]

This can be useful when you need an initialized collection of a known size.

Accessing Array Elements

Use an index.

let languages = ["Swift", "Kotlin", "Dart"]

print(languages[0])

Output:

Swift

Another example:

print(languages[1])

Output:

Kotlin

And:

print(languages[2])

Output:

Dart

Be Careful with Invalid Array Indexes

Suppose:

let languages = ["Swift", "Kotlin", "Dart"]

There are three elements, so valid positions are:

0
1
2

Trying:

languages[5]

will cause a runtime error because that position does not exist.

For this reason, avoid accessing indexes unless you know they are valid.

first and last in Swift Arrays

Instead of manually using indexes, Swift provides:

.first

and:

.last

Example:

let languages = ["Swift", "Kotlin", "Dart"]

print(languages.first ?? "No language")
print(languages.last ?? "No language")

Output:

Swift
Dart

first and last return optional values because an array may be empty.

Count Array Elements

Use:

.count

Example:

let languages = ["Swift", "Kotlin", "Dart"]

print(languages.count)

Output:

Check Whether an Array Is Empty

Use:

.isEmpty

Example:

let languages: [String] = []

if languages.isEmpty {
    print("No languages found")
}

Output:

No languages found

This is generally clearer than:

languages.count == 0

Adding Elements to an Array

If the array is declared with var, you can modify it.

var languages = ["Swift", "Kotlin"]

Add one item:

languages.append("Dart")

Result:

["Swift", "Kotlin", "Dart"]

Add Multiple Elements

Use:

append(contentsOf:)

Example:

var languages = ["Swift"]

languages.append(contentsOf: ["Kotlin", "Dart"])

Result:

["Swift", "Kotlin", "Dart"]

You can also use:

languages += ["Java", "Python"]

Insert an Element at a Specific Position

Use:

insert(_:at:)

Example:

var languages = ["Swift", "Dart"]

languages.insert("Kotlin", at: 1)

Result:

["Swift", "Kotlin", "Dart"]

Update an Array Element

Example:

var languages = ["Swift", "Kotlin", "Dart"]

languages[1] = "Java"

Result:

["Swift", "Java", "Dart"]

Remove an Array Element

Use:

remove(at:)

Example:

var languages = ["Swift", "Kotlin", "Dart"]

languages.remove(at: 1)

Result:

["Swift", "Dart"]

Remove the First Element

var numbers = [10, 20, 30]

numbers.removeFirst()

Result:

[20, 30]

Remove the Last Element

var numbers = [10, 20, 30]

numbers.removeLast()

Result:

[10, 20]

Remove All Array Elements

var languages = ["Swift", "Kotlin", "Dart"]

languages.removeAll()

Result:

[]

Check Whether an Array Contains a Value

Use:

contains()

Example:

let languages = ["Swift", "Kotlin", "Dart"]

if languages.contains("Swift") {
    print("Swift found")
}

Output:

Swift found

Loop Through a Swift Array

Use a for-in loop.

let languages = ["Swift", "Kotlin", "Dart"]

for language in languages {
    print(language)
}

Output:

Swift
Kotlin
Dart

This is one of the most common ways to process arrays.

Get Array Index and Value Together

Use:

enumerated()

Example:

let languages = ["Swift", "Kotlin", "Dart"]

for (index, language) in languages.enumerated() {
    print("\(index): \(language)")
}

Output:

0: Swift
1: Kotlin
2: Dart

Sort an Array

For an immutable array, use:

sorted()

Example:

let numbers = [40, 10, 30, 20]

let sortedNumbers = numbers.sorted()

print(sortedNumbers)

Output:

[10, 20, 30, 40]

The original array remains unchanged.

Sort in Descending Order

let numbers = [40, 10, 30, 20]

let descending = numbers.sorted(by: >)

print(descending)

Output:

[40, 30, 20, 10]

sorted() vs sort()

These are different.

sorted() returns a new sorted collection:

let sortedNumbers = numbers.sorted()

sort() modifies a mutable array:

var numbers = [30, 10, 20]

numbers.sort()

Now:

[10, 20, 30]

Reverse an Array

Use:

reversed()

Example:

let numbers = [1, 2, 3, 4]

let reversedNumbers = Array(numbers.reversed())

print(reversedNumbers)

Output:

[4, 3, 2, 1]

map() with Arrays

map() transforms every element.

Example:

let numbers = [1, 2, 3, 4]

let doubled = numbers.map { number in
    number * 2
}

Result:

[2, 4, 6, 8]

A shorter version:

let doubled = numbers.map { $0 * 2 }

filter() with Arrays

filter() keeps elements that match a condition.

Example:

let numbers = [1, 2, 3, 4, 5, 6]

let evenNumbers = numbers.filter { number in
    number % 2 == 0
}

Result:

[2, 4, 6]

reduce() with Arrays

reduce() combines array elements into a single result.

Example:

let numbers = [10, 20, 30]

let total = numbers.reduce(0, +)

print(total)

Output:

What Is a Set in Swift?

A Set stores unique values of the same type.

Unlike an array, a set does not maintain values for access by integer position.

The most important rule is:

A Swift Set does not store duplicate elements.

Example:

var languages: Set<String> = ["Swift", "Kotlin", "Dart"]

Why Use a Set?

Suppose your app stores selected category IDs.

You don’t want the same ID stored multiple times.

A set is ideal:

var selectedIDs: Set<Int> = [1, 2, 3]

If you attempt to add:

selectedIDs.insert(2)

the set still contains each value only once.

Creating a Swift Set

You should normally explicitly specify that the collection is a Set.

let languages: Set<String> = [
    "Swift",
    "Kotlin",
    "Dart"
]

For integers:

let numbers: Set<Int> = [10, 20, 30]

Creating an Empty Set

var languages = Set<String>()

Or:

var languages: Set<String> = []

Adding Values to a Set

Use:

insert()

Example:

var languages: Set<String> = ["Swift", "Kotlin"]

languages.insert("Dart")

The set now contains all three values.

Remember: do not rely on the printed order of a set.

Duplicate Values in Sets

Consider:

var numbers: Set<Int> = [1, 2, 3]

numbers.insert(2)

The set remains logically:

1, 2, 3

There is only one 2.

This is one of the main reasons to choose a set over an array.

Remove an Element from a Set

Use:

remove()

Example:

var languages: Set<String> = ["Swift", "Kotlin", "Dart"]

languages.remove("Kotlin")

Now Kotlin is no longer in the set.

Remove All Set Elements

languages.removeAll()

The set becomes empty.

Check Whether a Set Contains a Value

Use:

contains()

Example:

let languages: Set<String> = ["Swift", "Kotlin", "Dart"]

if languages.contains("Swift") {
    print("Swift found")
}

Output:

Swift found

Membership testing is one of the most common uses for sets.

Count Set Elements

print(languages.count)

Check Whether a Set Is Empty

if languages.isEmpty {
    print("Set is empty")
}

Loop Through a Set

let languages: Set<String> = ["Swift", "Kotlin", "Dart"]

for language in languages {
    print(language)
}

Do not assume the values will appear in a particular order.

If you need sorted output:

for language in languages.sorted() {
    print(language)
}

Swift Set Operations

Sets become especially powerful when comparing groups of values.

Suppose:

let frontend: Set<String> = [
    "HTML",
    "CSS",
    "JavaScript"
]

let mobile: Set<String> = [
    "Swift",
    "Kotlin",
    "JavaScript"
]

We can perform mathematical set operations.

Union

A union combines values from both sets without duplicates.

let allLanguages = frontend.union(mobile)

The result contains:

HTML
CSS
JavaScript
Swift
Kotlin

Intersection

Intersection returns values present in both sets.

let common = frontend.intersection(mobile)

Result:

JavaScript

Subtracting

Find values in one set but not the other:

let onlyFrontend = frontend.subtracting(mobile)

Result contains:

HTML
CSS

Symmetric Difference

Returns values that exist in either set but not both.

let difference = frontend.symmetricDifference(mobile)

JavaScript is excluded because it exists in both sets.

Subset and Superset

Suppose:

let languages: Set<String> = [
    "Swift",
    "Kotlin",
    "Dart"
]

let appleLanguages: Set<String> = [
    "Swift"
]

Check subset:

appleLanguages.isSubset(of: languages)

Result:

true

Check superset:

languages.isSuperset(of: appleLanguages)

Result:

true

What Is a Dictionary in Swift?

A Dictionary stores values using unique keys.

Instead of accessing data using an integer index, you use a key.

Example:

let user = [
    "name": "Alex",
    "city": "Jaipur"
]

Conceptually:

Key        Value

name       Alex
city       Jaipur

This is called a key-value pair.

Dictionary Syntax

A dictionary type is written as:

[KeyType: ValueType]

For example:

[String: String]

means:

String key → String value

Another example:

[String: Int]

means:

String key → Int value

Creating a Dictionary

let user: [String: String] = [
    "name": "Alex",
    "city": "Jaipur",
    "language": "Swift"
]

Swift may also infer the type:

let user = [
    "name": "Alex",
    "city": "Jaipur"
]

Creating an Empty Dictionary

var user: [String: String] = [:]

Or:

var user = [String: String]()

Accessing Dictionary Values

Use a key:

let user = [
    "name": "Alex",
    "city": "Jaipur"
]

print(user["name"])

Dictionary access returns an optional because the requested key may not exist.

A better approach:

print(user["name"] ?? "Unknown")

Output:

Alex

Why Does Dictionary Access Return an Optional?

Suppose:

user["email"]

but there is no "email" key.

Swift needs a way to represent:

No value exists

Therefore dictionary lookup returns an optional.

You can handle it using:

if let name = user["name"] {
    print(name)
}

Or provide a fallback:

let email = user["email"] ?? "Not available"

Add a New Dictionary Value

Use:

var user = [
    "name": "Alex",
    "city": "Jaipur"
]

user["language"] = "Swift"

Now the dictionary contains the new key-value pair.

Update a Dictionary Value

user["city"] = "Delhi"

If "city" already exists, its value is updated.

updateValue() in Dictionaries

You can also use:

user.updateValue("Mumbai", forKey: "city")

One useful difference is that updateValue returns the previous value as an optional.

Remove a Dictionary Value

Set the value to nil:

user["city"] = nil

Or use:

user.removeValue(forKey: "city")

Count Dictionary Items

print(user.count)

Check Whether a Dictionary Is Empty

if user.isEmpty {
    print("Dictionary is empty")
}

Loop Through a Dictionary

Use:

for (key, value) in user {
    print("\(key): \(value)")
}

Do not rely on dictionary iteration order.

If presentation order matters, sort the keys or transform the data appropriately.

Loop Through Dictionary Keys

for key in user.keys {
    print(key)
}

Loop Through Dictionary Values

for value in user.values {
    print(value)
}

Convert Dictionary Keys to an Array

let keys = Array(user.keys)

Now keys is an array.

Similarly:

let values = Array(user.values)

Dictionary with Different Value Types

A dictionary normally has one specific value type.

This works:

let scores: [String: Int] = [
    "Alex": 90,
    "John": 85,
    "Emma": 95
]

Here:

Key   → String
Value → Int

Trying to casually mix unrelated value types is usually a sign that a custom model would be better.

Use Structs Instead of Mixed Dictionaries

Beginners sometimes try to represent a user like this:

name → String
age → Int
isActive → Bool

Instead of weakening type safety with an overly generic dictionary, create a model:

struct User {
    let name: String
    let age: Int
    let isActive: Bool
}

Then:

let user = User(
    name: "Alex",
    age: 25,
    isActive: true
)

This is generally much cleaner for structured application data.

Dictionary of Arrays

Dictionaries can contain arrays as values.

Example:

let skills: [String: [String]] = [
    "iOS": ["Swift", "SwiftUI"],
    "Android": ["Kotlin", "Jetpack Compose"],
    "Flutter": ["Dart", "Flutter"]
]

Access:

if let iosSkills = skills["iOS"] {
    print(iosSkills)
}

Output:

["Swift", "SwiftUI"]

Array of Dictionaries

You can also create an array containing dictionaries.

let users: [[String: String]] = [
    [
        "name": "Alex",
        "city": "Jaipur"
    ],
    [
        "name": "John",
        "city": "Delhi"
    ]
]

Access:

print(users[0]["name"] ?? "Unknown")

However, for real application models, an array of structs is usually easier to maintain.

Array of Structs: A Realistic Swift Example

Define:

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

Create:

let users = [
    User(id: 1, name: "Alex", city: "Jaipur"),
    User(id: 2, name: "John", city: "Delhi"),
    User(id: 3, name: "Emma", city: "Mumbai")
]

Now:

for user in users {
    print(user.name)
}

Output:

Alex
John
Emma

This pattern appears constantly in real Swift and iOS applications.

Array vs Set: Which Should You Use?

Use an Array when:

Order matters
Duplicate values are allowed
You need index-based access
You are displaying ordered lists

Example:

let recentSearches = [
    "Swift",
    "Kotlin",
    "Swift"
]

Duplicates may be meaningful, so an array makes sense.

Use a Set when:

Every value should be unique
Order is not important
You frequently test membership
You need set operations

Example:

let selectedCategoryIDs: Set<Int> = [1, 2, 3]

Array vs Dictionary: Which Should You Use?

Use an array when your values are primarily an ordered sequence.

Example:

let products = [
    "iPhone",
    "MacBook",
    "iPad"
]

Use a dictionary when values need to be associated with unique keys.

Example:

let prices = [
    "iPhone": 999,
    "MacBook": 1299,
    "iPad": 599
]

Now you can retrieve a price using the product name as the key.

Set vs Dictionary

A Set stores:

Unique values

A Dictionary stores:

Unique keys → Associated values

For example:

let blockedUserIDs: Set<Int> = [10, 15, 20]

You only care whether an ID exists.

But:

let usernames: [Int: String] = [
    10: "Alex",
    15: "John",
    20: "Emma"
]

Each ID is associated with additional data.

When Should You Use Each Collection?

A useful rule is:

Need an ordered list?
        ↓
      Array

Need unique values?
        ↓
       Set

Need key → value mapping?
        ↓
   Dictionary

Real-World Array Examples

Arrays are extremely common in iOS development.

Product List

let products = [
    "iPhone",
    "MacBook",
    "Apple Watch"
]

Chat Messages

let messages = [
    "Hello",
    "How are you?",
    "I'm good"
]

Notifications

let notifications = [
    "New message",
    "Order shipped",
    "Payment successful"
]

API Results

A decoded API response often becomes:

[Product]

or:

[User]

Real-World Set Examples

Sets are useful for unique selections.

Selected IDs

var selectedIDs: Set<Int> = [1, 5, 9]

User Permissions

let permissions: Set<String> = [
    "read",
    "write",
    "delete"
]

Favorite Product IDs

var favoriteProductIDs: Set<Int> = [
    10,
    20,
    30
]

Checking:

favoriteProductIDs.contains(20)

is a natural set operation.

Real-World Dictionary Examples

Application Settings

let settings = [
    "theme": "dark",
    "language": "English"
]

Country Codes

let countryCodes = [
    "India": "+91",
    "USA": "+1",
    "UK": "+44"
]

User Scores

let scores = [
    "Alex": 90,
    "John": 85,
    "Emma": 95
]

Mutability: let vs var with Collections

This is extremely important.

If you use:

let

the collection cannot be modified.

Example:

let languages = ["Swift", "Kotlin"]

You cannot:

languages.append("Dart")

Instead:

var languages = ["Swift", "Kotlin"]

languages.append("Dart")

A useful rule:

let → Collection does not change

var → Collection can change

Use let whenever the collection should remain unchanged.

Value Semantics of Swift Collections

Swift’s standard Array, Set, and Dictionary types are value types.

Consider:

var first = ["Swift", "Kotlin"]

var second = first

second.append("Dart")

Now second contains Dart, while modifying it does not conceptually mean that first must also change.

This value-semantic behavior makes Swift collections easier to reason about.

Swift may use internal optimizations such as copy-on-write to avoid unnecessary copying until modification is required.

Hashable and Sets

Elements stored in a Set must conform to:

Hashable

Many built-in types already conform to Hashable, including:

String
Int
Bool

That’s why this works:

let numbers: Set<Int> = [1, 2, 3]

Custom types can also conform to Hashable.

Example:

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

Now:

let users: Set<User> = [
    User(id: 1, name: "Alex"),
    User(id: 2, name: "John")
]

can be created.

Hashable and Dictionary Keys

Dictionary keys must also conform to Hashable.

For example:

[String: Int]

works because String conforms to Hashable.

Likewise:

[Int: String]

works because Int conforms to Hashable.

Common Array Mistakes

Mistake 1: Invalid Index

let numbers = [10, 20]

print(numbers[5])

This causes a runtime error.

Always make sure an index exists before accessing it.

Mistake 2: Modifying a let Array

Incorrect:

let numbers = [1, 2, 3]

numbers.append(4)

Correct:

var numbers = [1, 2, 3]

numbers.append(4)

Mistake 3: Expecting One Array to Store Arbitrary Types

A normal strongly typed Swift array should contain values compatible with its element type.

For example:

let numbers: [Int] = [1, 2, 3]

You cannot simply append:

"Swift"

to [Int].

Common Set Mistakes

Mistake 1: Expecting Duplicates

let numbers: Set<Int> = [1, 1, 2, 2, 3]

The set contains only unique values.

Mistake 2: Expecting Index-Based Access

You should not treat a set like:

numbers[0]

A set is not an integer-indexed ordered collection like an array.

Mistake 3: Relying on Set Order

Never write logic that assumes a Set will iterate in the same order you used when creating it.

If you need ordered presentation:

numbers.sorted()

returns a sorted array.

Common Dictionary Mistakes

Mistake 1: Forgetting Dictionary Lookup Is Optional

Instead of assuming:

user["name"]

always exists, safely handle it:

if let name = user["name"] {
    print(name)
}

or:

let name = user["name"] ?? "Unknown"

Mistake 2: Duplicate Keys

Dictionary keys must be unique.

You cannot use the same key to represent two independent values simultaneously.

Assigning another value to an existing key updates that key’s associated value.

Mistake 3: Relying on Dictionary Order

A dictionary is designed around keys, not positional ordering.

If UI presentation order matters, create an ordered representation before displaying the data.

Array, Set & Dictionary Cheat Sheet

Array

Create:

var languages = ["Swift", "Kotlin"]

Add:

languages.append("Dart")

Insert:

languages.insert("Java", at: 1)

Access:

languages[0]

Remove:

languages.remove(at: 0)

Count:

languages.count

Contains:

languages.contains("Swift")

Loop:

for language in languages {
    print(language)
}

Set

Create:

var languages: Set<String> = [
    "Swift",
    "Kotlin"
]

Insert:

languages.insert("Dart")

Remove:

languages.remove("Kotlin")

Contains:

languages.contains("Swift")

Union:

firstSet.union(secondSet)

Intersection:

firstSet.intersection(secondSet)

Difference:

firstSet.subtracting(secondSet)

Dictionary

Create:

var user = [
    "name": "Alex",
    "city": "Jaipur"
]

Access:

user["name"]

Add:

user["language"] = "Swift"

Update:

user["city"] = "Delhi"

Remove:

user.removeValue(forKey: "city")

Loop:

for (key, value) in user {
    print("\(key): \(value)")
}

Practice Exercise 1: Array

Create an array containing:

Swift
Kotlin
Dart
Java
Python

Then:

Print the first element.
Print the last element.
Add C++.
Remove Java.
Print the total number of languages.
Loop through every language.

Practice Exercise 2: Set

Create:

var favoriteNumbers: Set<Int>

Add five numbers.

Then:

Add one duplicate.
Print the count.
Check whether 10 exists.
Remove one number.
Loop through the set.

Observe how duplicate values behave.

Practice Exercise 3: Dictionary

Create a dictionary containing:

name
city
language

Then:

Print the name.
Change the city.
Add a country.
Remove the language.
Loop through all key-value pairs.

Practice Exercise 4: Filter an Array

Create:

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

Create a new array containing only even numbers.

Expected result:

[2, 4, 6, 8, 10]

Hint:

filter()

Practice Exercise 5: Set Comparison

Create:

let iosSkills: Set<String>
let androidSkills: Set<String>

Add several technologies to both.

Then find:

All technologies
Common technologies
iOS-only technologies
Technologies present in only one of the sets

Use:

union
intersection
subtracting
symmetricDifference

Frequently Asked Questions

What is an Array in Swift?

An Array is an ordered collection of values of the same type. Arrays allow duplicate values and support position-based access through indexes.

What is a Set in Swift?

A Set is a collection of unique values. Sets are useful when duplicates should not exist and when membership testing or mathematical set operations are important.

What is a Dictionary in Swift?

A Dictionary stores key-value pairs. Every key is unique and is used to retrieve its associated value.

What is the difference between Array and Set in Swift?

An Array is ordered, supports duplicate values, and provides index-based access.

A Set stores unique values and is designed around membership rather than integer-position access.

What is the difference between Array and Dictionary?

An Array stores an ordered sequence of values.

A Dictionary associates unique keys with values.

Can Swift arrays contain duplicates?

Yes.

For example:

let numbers = [1, 1, 2, 2, 3]

is valid.

Can Swift Sets contain duplicates?

No.

A set keeps unique elements.

Can dictionaries have duplicate keys?

No.

Dictionary keys are unique.

Assigning a value to an existing key updates that key’s associated value.

Do Swift arrays start at index 0?

Yes.

For:

let languages = ["Swift", "Kotlin"]

Swift is at index 0.

Are Swift dictionaries ordered?

You should not rely on a dictionary’s iteration order for application logic or presentation. Access dictionary data using keys.

Are Swift Sets ordered?

Sets do not provide the positional ordering semantics of arrays. Do not depend on their iteration order.

Which collection should I use for API data?

It depends on the structure of your decoded model.

A list of products will commonly become:

[Product]

A key-value mapping may become:

[String: SomeType]

Use the collection that accurately represents your data rather than choosing one collection for every API response.

Which Swift collection is fastest?

There is no useful universal answer.

Different collections are optimized for different operations.

Choose based on semantics first:

Ordered sequence → Array

Unique membership → Set

Key-value lookup → Dictionary

Performance optimization should be based on the actual operations and requirements of your application.

What Should You Learn Next?

Once you understand Swift collections, continue with:

Arrays, Sets & Dictionaries
           ↓
Optionals
           ↓
Functions
           ↓
Structs
           ↓
Classes
           ↓
Enums
           ↓
Closures
           ↓
Protocols
           ↓
Generics
           ↓
Async/Await
           ↓
SwiftUI

You will use collections throughout almost every real Swift project.

Final Thoughts

Arrays, Sets, and Dictionaries are fundamental Swift collection types, but they solve different problems.

Remember this simple rule:

ARRAY
Ordered collection
Duplicates allowed
Index-based access

SET
Unique values
No integer-position access
Excellent for membership

DICTIONARY
Key-value pairs
Unique keys
Access values using keys

For example, imagine an eCommerce application.

You might use:

var products: [Product]

for an ordered product list.

You might use:

var favoriteProductIDs: Set<Int>

to keep unique favorite IDs.

And you might use:

var productQuantities: [Int: Int]

to map each product ID to a quantity.

That is the key to choosing the correct Swift collection:

Use an Array when order matters, a Set when uniqueness matters, and a Dictionary when you need to associate keys with values.

Once you understand these three collection types properly, working with API responses, user data, lists, filters, selections, and application state in Swift becomes much easier.

Swift Arrays, Sets & Dictionaries Explained: Complete Beginner’s Guide

What Are Collections in Swift?

Swift Array vs Set vs Dictionary

Array

Set

Dictionary

What Is an Array in Swift?

Creating an Array in Swift

Creating an Array of Integers

Creating an Empty Array

Why Does an Empty Array Need a Type?

Array with Repeated Values

Accessing Array Elements

Be Careful with Invalid Array Indexes

first and last in Swift Arrays

Count Array Elements

Check Whether an Array Is Empty

Adding Elements to an Array

Add Multiple Elements

Insert an Element at a Specific Position

Update an Array Element

Remove an Array Element

Remove the First Element

Remove the Last Element

Remove All Array Elements

Check Whether an Array Contains a Value

Loop Through a Swift Array

Get Array Index and Value Together

Sort an Array

Sort in Descending Order

sorted() vs sort()

Reverse an Array

map() with Arrays

filter() with Arrays

reduce() with Arrays

What Is a Set in Swift?

Why Use a Set?

Creating a Swift Set

Creating an Empty Set

Adding Values to a Set

Duplicate Values in Sets

Remove an Element from a Set

Remove All Set Elements

Check Whether a Set Contains a Value

Count Set Elements

Check Whether a Set Is Empty

Loop Through a Set

Swift Set Operations

Union

Intersection

Subtracting

Symmetric Difference

Subset and Superset

What Is a Dictionary in Swift?

Dictionary Syntax

Creating a Dictionary

Creating an Empty Dictionary

Accessing Dictionary Values

Why Does Dictionary Access Return an Optional?

Add a New Dictionary Value

Update a Dictionary Value

updateValue() in Dictionaries

Remove a Dictionary Value

Count Dictionary Items

Check Whether a Dictionary Is Empty

Loop Through a Dictionary

Loop Through Dictionary Keys

Loop Through Dictionary Values

Convert Dictionary Keys to an Array

Dictionary with Different Value Types

Use Structs Instead of Mixed Dictionaries

Dictionary of Arrays

Array of Dictionaries

Array of Structs: A Realistic Swift Example

Array vs Set: Which Should You Use?

Array vs Dictionary: Which Should You Use?

Set vs Dictionary

When Should You Use Each Collection?

Real-World Array Examples

Product List