Swift Sets

A set is a collection of unique data. That is, elements of a set cannot be duplicate. For example,

Suppose we want to store information about student IDs. Since student IDs cannot be duplicate, we can use a set.

Create a Set in Swift

Here's how we can create a set in Swift.

// create a set of integer type
var studentID : Set = [112, 114, 116, 118, 115]

print("Student ID: \(studentID)")

Output

Student ID: [112, 114, 115, 118, 116]

In the above example, notice the statement,

var studentID : Set = [112, 114, 115, 118, 116]

Here, the Set keyword specifies that studentID is a set. Since all the elements of the set are integers, studentID is a set of Int type.

However, we can also specify the type of set as

var studentID : Set<Int> = [112, 114, 115, 116, 118]

Note: When you run this code, you might get output in a different order. This is because the set has no particular order.

Add Elements to a Set

We use the insert() method to add the specified element to a set. For example,

var numbers: Set = [21, 34, 54, 12]

print("Initial Set: \(numbers)")

// using insert method
numbers.insert(32)

print("Updated Set: \(numbers)") 

Output

Initial Set: [54, 21, 34, 12]
Updated Set: [54, 21, 34, 12, 32]

In the above example, we have created a set named employeeID. Notice the line,

numbers.insert(32)

Here, insert() adds 32 to our set.

Remove an Element from a Set

We use the remove() method to remove the specified element from a set. For example,

var languages: Set = ["Swift", "Java", "Python"]

print("Initial Set: \(languages)")

// remove Java from a set
let removedValue = languages.remove("Java")

print("Set after remove(): \(languages)")

Output

Initial Set: ["Python", "Java", "Swift"]
Set after remove(): ["Python", "Swift"]

Similarly, we can also use

• removeFirst() - to remove the first element of a set
• removeAll() - to remove all elements of a set

Other Set Methods

Iterate Over a Set

We can use the for loop to iterate over the elements of a set. For example,

let fruits: Set = ["Apple", "Peach", "Mango"]

print("Fruits:")

// for loop to access each fruits
for fruit in fruits {
  print(fruit)
}

Output

Fruits:
Peach
Mango
Apple

Find Number of Set Elements

We can use the count property to find the number of elements present in a Set. For example,

let evenNumbers = [2,4,6,8]
print("Set: \(evenNumbers)")

// find number of elements
print("Total Elements: \(evenNumbers.count)")

Output

Set: [2, 6, 8, 4]
Total Elements: 4

Swift Set Operations

Swift Set provides different built-in methods to perform mathematical set operations like union, intersection, subtraction, and symmetric difference.

1. Union of Two Sets

The union of two sets A and B include all the elements of set A and B.

We use the union() method to perform the set union operation. For example,

// first set
let setA: Set = [1, 3, 5]
print("Set A: ", setA)

// second set
let setB: Set = [0, 2, 4]
print("Set B: ", setB)

// perform union operation
print("Union: ", setA.union(setB))

Output

Set A:  [1, 5, 3]
Set B:  [0, 2, 4]
Union: [0, 5, 2, 4, 1, 3]

Note: setA.union(setB) is equivalent to A ⋃ B set operation.

2. Intersection between Two Sets

The intersection of two sets A and B include the common elements between set A and B.

We use the intersection() method to perform the intersection between two sets. For example,

// first set
let setA: Set = [1, 3, 5]
print("Set A: ",  setA)

// second set
let setB: Set = [1, 2, 3]
print("Set B: ",  setB)

// perform intersection operation
print("Intersection: ", setA.intersection(setB))

Output

Set A:  [5, 3, 1]
Set B:  [1, 2, 3]
Intersection:  [3, 1]

Note: setA.intersection(setB) is equivalent to A ⋂ B set operation.

3. Difference between Two Sets

The difference between two sets A and B include elements of set A that are not present on set B.

We use the subtracting() method to perform the difference between two sets. For example,

// first set
let setA: Set = [2, 3, 5]
print("Set A: ",  setA)

// second set
let setB: Set = [1, 2, 6]
print("Set B: ",  setB)

// perform subtraction operation
print("Subtraction: ", setA.subtracting(setB))

Output

Set A:  [3, 5, 2]
Set B:  [1, 6, 2]
Subtraction:  [3, 5]

Note: setA.substracting(setB) is equivalent to A - B set operation.

4. Symmetric Difference between Two Sets

The symmetric difference between two sets A and B includes all elements of A and B without the common elements.

We use the symmetricDifference() method to perform symmetric difference between two sets. For example,

// first set
let setA: Set = [2, 3, 5]
print("Set A: ",  setA)

// second set
let setB: Set = [1, 2, 6]
print("Set B: ",  setB)

// perform symmetric difference operation
print("Symmetric Difference: ", setA.symmetricDifference(setB))

Output

Set A:  [5, 2, 3]
Set B:  [2, 6, 1]
Symmetric Difference:  [1, 6, 3, 5]

5. Check Subset of a Set

Set B is said to be the subset of set A if all elements of B are also present in A.

We use the Subset() method to check if one set is a subset of another or not. For example,

// first set
let setA: Set = [1, 2, 3, 5, 4]
print("Set A: ",  setA)

// second set
let setB: Set = [1, 2]
print("Set B: ",  setB)

// check if setB is subset of setA or not
print("Subset: ", setB.isSubset(of: setA))

Output

Set A:  [3, 1, 2, 5]
Set B:  [1, 2]
Subset:  true

Check if two sets are equal

We can use the == operator to check whether two sets are equal or not. For example,

let setA: Set = [1, 3, 5]
let setB: Set = [3, 5, 1]

if setA == setB {
  print("Set A and Set B are equal")
}
else {
  print("Set A and Set B are different")
}

Output

Set A and Set B are equal

In the above example, setA and setB have the same elements, so the condition

if setA == setB

evaluates to true. Hence, the statement print("Set A and Set B are same") inside the if is executed.

Create an Empty Set

In Swift, we can also create an empty set. For example,

var emptySet = Set<Int>()
print("Set:", emptySet)

Output

Set: [ ]

It is important to note that, while creating an empty set, we must specify the data type inside the <> followed by an initializer syntax ().

Here, <Int>() specifies that the empty set can only store integer data elements.