Set are basically a collection of items that aren’t ordered but are unique. Let's go over different operations/functions that Swift has when it comes to Sets.
Creating a Set
Initialize an empty set
Sets in swift are of a generic nature so they can hold any type if it conforms to Hashable Protocol. For the simplicity of this article, we will use String and Int.
var fruits = Set<String>()
Initialize a Set with elements
We can also initialize a set with some default elements.
var fruits:Set<String> = ["apple","mango","guava"]
Initialize a Set with a capacity
We can set a space pre-allocated for minimum number/capacity
var fruits = Set<String>(minimumCapacity: 2)
Inspecting a set
Check for empty
Since Set conforms to Collection Protocol we can use a check for isEmpty.
var fruits = Set<String>()
fruits.isEmpty //true
Count
We can easily get the number of elements in our Set by accessing the count property.
var fruits:Set<String> = ["apple","mango","guava"]
fruits.count //3
Capacity
This property returns the number of elements set can contain without allocation any additional storage
var fruits:Set<String> = ["apple","mango","guava"]
fruits.capacity //3
Contains
This function is really useful when it comes to checking if a set contains an element or not. This function returns a bool.
var fruits:Set<String> = ["apple","mango","guava"]
fruits.contains("grape") // false
fruits.contains("apple") // true
Adding Elements
Insert
We can add an element to our Set in swift using the insert function. This will only insert if the elements don't exist already.
var fruits:Set<String> = ["apple","mango","guava"]
fruits.insert("grape") //(inserted true, memberAfterInsert "grape")
print(fruits) //["mango", "apple", "guava", "grape"]
If you pay attention to the output of the insert function, we get a tuple back which gives us info regarding whether the element was inserted or not. This value from the tuple is very useful to check if the insertion actually happened.
ReserveCapacity
This reserves enough space to hold the number of elements we want.
var fruits = Set<String>()
fruits.reserveCapacity(5)
Removing Elements
Filter
Since Sets conforms to Collection protocol, we use advanced operations like filters very easily.
var numbers:Set<Int> = [1,2,3,4,5,6,7,8,9,10]
let evenNUmbers = numbers.filter {
return $0%2 == 0
}
evenNUmbers //{6, 10, 4, 2, 8}
Remove
This function removes the element that is passed from the Set
var fruits:Set<String> = ["apple","mango","guava"] //{"apple", "mango", "guava"}
fruits.remove("apple")
fruits //{"mango", "guava"}
RemoveFirst
This removes the first element from the unordered set. Always remember it can remove any element as it in an unordered list.
var fruits:Set<String> = ["apple","mango","guava"] //{"apple", "mango", "guava"}
fruits.removeFirst()
fruits //{"mango", "guava"}
RemoveAll
This clears the Set.
var fruits:Set<String> = ["apple","mango","guava"] //{"apple", "mango", "guava"}
fruits.removeAll() //Set([])
Combining Sets
Union
This helps us combine results from two sets. Here we take two sets, one set with even number and one with odd numbers.
let evenNumber:Set<Int> = [2,4,6,8] //{2, 4, 8, 6}
let oddNumbers:Set<Int> = [1,3,5,7] // {7, 3, 1, 5}
let result = evenNumber.union(oddNumbers) //{4, 7, 3, 1, 6, 2, 5, 8}
If you see the code above the result set contains elements from both sets
Intersection
This helps us get the common part from both sets and return set with that. Let's look at the example below.
let numbers:Set<Int> = [1,2,3,4,5,6,7,8] //{2, 4, 8, 6}
let oddNumbers:Set<Int> = [1,3,5,7] // {7, 3, 1, 5}
let result = numbers.intersection(oddNumbers)//{5, 1, 7, 3}
Symmetric Difference
This function is exactly the opposite of Intersection and results in a Set that removes the common elements and returns everything else. Let's take an example
let letters:Set<Character> = ["a","b","c","d"] //{"d", "a", "b", "c"}
let vowels:Set<Character> = ["a","e","i","o","u"] // {"u", "a", "o", "e", "i"}
let result = letters.symmetricDifference(vowels)//{"u", "d", "c", "b", "i", "e", "o"}
In the example above, character a is common in letters and vowels set so the result set contains everything from both sets except the common part a .
Subtract
This function helps in removing the elements from a given set. Let’s take an example
var numbers:Set<Int> = [1,2,3,4,5,6,7,8,9,10] //{1, 4, 6, 3, 7, 10, 5, 2, 8, 9}
let evenNumbers:Set<Int> = [2,4,6,8] //{4, 2, 6, 8}
numbers.subtract(evenNumbers) //{1, 3, 7, 10, 5, 9}
If you look at the example above, after subtracting evenNumbers set from numbersSet we got a set which now has only even numbers.
Finding Elements
Min
This gives you a minimum element of the set.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
numbers.min() //1
Max
This gives you the maximum of the set.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
numbers.max() //4
First(where:)
This helps you find the element in the set that satisfy a condition in the where clause. Please note, since the set is an unordered collection you will get different results running the same code below as it just returns the first one it matches the required condition.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
let result = numbers.first { $0%2 == 0}//4
print(result) //4
Transforming a Set
Map
As sets implement the collection protocol we can use advanced function like map. Map basically transforms every element of the collection the way we want and gives us a list. Let's say we have a set of numbers 1,2,3,4. Our map will multiple each one of them by 2.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
let result = numbers.map{$0 * 2}
print(result) // [2,4,6,8]
Reduce
Reduce can be used to combine the result of the collection. In our example, we will add the elements of our Set.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
let result = numbers.reduce(0) {$0 + $1}
print(result) // 10
Iterating Over a Set
ForEach
This will help us calling the same closure/transformation on each element in our Set. In the example below, we are just printing each and every element of the Set.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
numbers.forEach {
print($0)
}
Enumerated
This is another way we can iterate over Set’s element. In this case, we will access to index too along with the element itself.
var numbers:Set<Int> = [1,2,3,4] //{2, 3, 4, 1}
for (index,element) in numbers.enumerated() {
print("index is \(index) and element is \(element)")
}
Here is the output.
index is 0 and element is 2
index is 1 and element is 3
index is 2 and element is 4
index is 3 and element is 1
Conclusion
Sets hold unordered collection but their ability to hold unique value makes them a very useful data structure in our day to day implementation. I hope after reading this article you are all set to use Sets.