Understanding Sets in Swift.

One of the essential data structures in Swift is a set. A set is an unordered collection of unique elements. In this post, we will explore the concept of sets in Swift, how to create, access, and manipulate them.

Creating a Set in Swift:

To create a set in Swift, we use the Set keyword followed by angle brackets enclosing the data type of elements in the set. For example, to create a set of integers, we write:

var setOfNumbers: Set<Int> = [1, 2, 3, 4, 5]

This creates a set of integers with the values 1, 2, 3, 4, and 5. We can also create an empty set using the same syntax:

var emptySet: Set<Int> = []

Alternatively, we can omit the data type and let Swift infer it based on the elements in the set, as shown below:

var setOfNumbers = Set([1, 2, 3, 4, 5])

This creates a set of integers with the same values as the previous example.

Accessing and Modifying Sets:

We can access and modify the elements in a set using various methods. For example, to add a new element to a set, we use the insert method, as shown below:


This adds the element 6 to the set. To remove an element from a set, we use the remove method:


This removes the element 5 from the set. We can also remove all the elements from a set using the removeAll method:


This removes all the elements from the set.

We can also check if a set contains a specific element using the contains method:

if setOfNumbers.contains(3) {
  print("The set contains the element 3")

This prints "The set contains the element 3" if the set contains the element 3.

Iterating Over a Set: We can iterate over the elements in a set using a for loop:

for number in setOfNumbers {

This prints all the elements in the set. Note that the order of elements in a set is undefined, which means that the order of elements in the output may vary each time the loop is executed.

Set Operations:

Sets in Swift support various set operations, such as union, intersection, and difference. The union operation combines the elements of two sets:

let set1: Set<Int> = [1, 2, 3]
let set2: Set<Int> = [3, 4, 5]
let unionSet = set1.union(set2)
print(unionSet) // prints [1, 2, 3, 4, 5]

The intersection operation returns the elements that are common to two sets:

let intersectionSet = set1.intersection(set2)
print(intersectionSet) // prints [3]

The difference operation returns the elements that are in one set but not in the other:

let differenceSet = set1.symmetricDifference(set2)
print(differenceSet) // prints [1, 2, 4, 5]


In conclusion, sets are a powerful data structure in Swift that allow us to store a collection of unique elements. We can create, access, and modify sets using various methods, and perform set operations to combine, intersect, or find the difference between sets.

Share on Twitter