In this tutorial, you will learn about sets, creating sets, modifying them and some common operations in sets.

In the previous Swift Arrays article, we learned about creating array that can hold multiple values in an ordered list.

But, if we have to make sure a list can hold a value only once, we use a set in Swift.

Sets is simply a container that can hold multiple value of data type in an unordered list and ensures unique element in the container (i.e each data appears only once).

Unordered list means you won't get the elements in the same order as you defined the items in the Set.

The main advantage of using Sets over arrays is when you need to ensure that an item only appears once and when the order of items is not important.

Values stored in a set must be **hashable**. This means it has to provide a `hashValue` property. This is important because sets are unordered and it uses `hashValue` is used to access the elements of the sets.

All of Swift's basic types (such as `String`

, `Int`

, `Double`

, and `Bool`

) are hashable by default, and can be used as set value types. However, you can also create your Hashable Type in Swift that can be stored in a set.

You can create an empty set by specifying the type as Set followed by the type of Data it can store within **< >**.

`let emptyIntSet:Set` = []
print(emptyIntSet)

**OR**

`let emptyIntSet:Set` = Set()
print(emptyIntSet)

When you run the program, the output will be:

[ ]

In the above program, we have declared a constant `emptyIntSet` of type `Set`

that can store multiple values of integer and initialized with 0 values.

Since, Swift is a type inference language, you can also create set directly without specifying the Data Type but must initialize with some values so that compiler can infer its type as:

```
let someIntSet:Set = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(someIntSet)
```

When you run the program, the output will be:

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

In the above program, we have declared a constant `someIntSet` that can store sets of Integer without specifying the type explicitly. However, we need to write `:Set`

when defining the variable, otherwise Swift will create an array for us.

Also, as arrays, we have initialized the set with **1, 2 ,3 ,4, 5, 6, 7, 8, 9** values using the `[]`

brackets.

As you've learnt, when you try to print the values inside the set as `print(someIntSet)`

, you will get the results in a different order than you have defined the items in the set because it stores value with no defined ordering. Therefore, each time when you access the order changes.

```
let someStrSet:Set = ["ab","bc","cd","de","ab"]
print(someStrSet)
```

When you run the program, the output will be:

["de", "ab", "cd", "bc"]

In the above program, we have defined a duplicate value **ab** in the set. And. when we try to access the value inside the set using `print(someStrSet)`

, the duplicate value is automatically removed from the set. Therefore, set guarantees unique elements/values inside it.

You can also declare a set with your own custom Hashable type in Swift. To learn more, visit *Swift Hashable*.

You cannot access elements of a set using *subscript syntax* as arrays. This is because sets are unordered and do not have indices to access the elements.

So, you need to access the set using its methods and properties or using for-in loops.

```
var someStrSet:Set = ["ab", "bc", "cd", "de"]
for val in someStrSet {
print(val)
}
```

When you run the program, the output will be:

de ab cd bc

In the above program, we get the `val` in different order than elements of a set because sets are unordered unlike arrays.

You can also access element of a set directly removing the value from the set as below:

```
var someStrSet:Set = ["ab", "bc", "cd", "de"]
let someVal = someStrSet.remove("cd")
print(someVal)
print(someStrSet)
```

When you run the program, the output will be:

Optional("cd") ["de", "ab", "bc"]

In the above program, you can see the remove method returns an optional string. Therefore, it's recommended you to do optional handling as below. To learn more about optionals, visit Swift Optionals.

```
var someStrSet:Set = ["ab", "bc", "cd", "de"]
if let someVal = someStrSet.remove("cd") {
print(someVal)
print(someStrSet)
} else {
print("cannot find element to remove")
}
```

When you run the program, the output will be:

cd ["de", "ab", "bc"]

You can add a new element to a set using `insert()`

method in Swift.

```
var someStrSet:Set = ["ab", "bc", "cd", "de"]
someStrSet.insert("ef")
print(someStrSet)
```

When you run the program, the output will be:

["ab", "de", "cd", "ef", "bc"]

In the above program, we used the set's `insert()`

method to add a new element to a set. Since, sets are unordered, the position of the inserted element isn't known.

Another main advantage of using Sets is you can perform set operations such as combining two sets together, determining which values two sets have in common etc. This operations are similar to the Set operation in Mathematics.

The union of two sets a and b is the set of elements which are in a, or b, or in both a and b.

```
let a: Set = [1, 3, 5, 7, 9]
let b: Set = [0, 2, 4, 6, 8]
print(a.union(b))
```

When you run the above program, the output will be:

[8, 2, 9, 4, 5, 7, 6, 3, 1, 0]

The intersection of two sets a and b is the set that contains all elements of a that also belong to b.

```
let a: Set = [1, 3, 5, 7, 9]
let b: Set = [0, 3, 7, 6, 8]
print(a.intersection(b))
```

When you run the above program, the output will be:

[7, 3]

Therefore, `print(a.intersection(b))`

outputs a new set with values **[7, 3]** that are common in both a and b.

The subtraction of two sets a and b is the set that contains all elements of a but removing the elements that also belong to b.

```
let a: Set = [1, 3, 5, 7, 9]
let b: Set = [0, 3, 7, 6, 8]
print(a.subtracting(b))
```

When you run the above program, the output will be:

[5, 9, 1]

Therefore, `print(a.subtracting(b))`

outputs a new set with values **[5, 9, 1]**.

The symmetric difference of two sets a and b is the set that contains all elements which are in either of the sets but not in both of them.

```
let a: Set = [1, 3, 5, 7, 9]
let b: Set = [0, 3, 7, 6, 8]
print(a.symmetricDifference(b))
```

When you run the above program, the output will be:

[5, 6, 8, 0, 1, 9]

Therefore, `print(a.symmetricDifference(b))`

outputs a new set with values **[5, 6, 8, 0, 1, 9]**.

You can use `==`

operator to check whether two sets contains same elements or not. It returns true if two sets contains same elements otherwise returns false.

```
let a: Set = [1, 3, 5, 7, 9]
let b: Set = [0, 3, 7, 6, 8]
let c:Set = [9, 7, 3, 1, 5]
if a == b {
print("a and b are same")
} else {
print("a and b are different")
}
if a == c {
print("a and c are same")
} else {
print("a and c are different")
}
```

When you run the above program, the output will be:

a and b are different a and c are same

You can also check relationship between two sets using the following methods:

`isSubset(of:)`

This method determines whether all of the values of a set are contained in the specified set.`isSuperset(of:)`

This method determines whether a set contains all of the values in a specified set`isStrictSubset(of:`

) or`isStrictSuperset(of:)`

: This method determines whether a set is a subset or superset, but not equal to, a specified set.`isDisjoint(with:)`

This method determines whether two sets have no values in common.

```
let a: Set = [1, 3, 5, 7, 9]
let b: Set = [0, 3, 1, 7, 6, 8, 9, 5]
print("isSubset:", a.isSubset(of: b))
print("isSuperset:", b.isSuperset(of: a))
print("isStrictSubset:", a.isStrictSubset(of: b))
print("isDisjointWith:", a.isDisjoint(with: b))
```

When you run the above program,the output will be:

isSubset: true isSuperset: true isStrictSubset: true isDisjointWith: false

Let's analyze methods used inside the print statement below:

`isSubset`

returns`true`

because the set b contains all the elements in a`isSuperset`

return`true`

because b contains all of the values of a.`isStrictSubset`

returns`true`

because set b contains all the element in a and both sets are not equal.`isDisjointWith`

returns`false`

because a and b have some values in common.

This property determines if a set is empty or not. It returns `true`

if a set does not contain any value otherwise returns `false`

.

```
let intSet:Set = [21, 34, 54, 12]
print(intSet.isEmpty)
```

When you run the program, the output will be:

false

This property is used to access first element of a set.

```
let intSet = [21, 34, 54, 12]
print(intSet.first)
```

When you run the program, the output will be:

Optional(54)

Since set is an unordered collection, the first property does not guarantee the first element of the set. You may get other value than 54.

Similarly, you can use `last`

property to access last element of a set.

The insert function is used to insert/append element in the set.

```
var intSet:Set = [21, 34, 54, 12]
intSet.insert(50)
print(intSet)
```

When you run the program, the output will be:

[54, 12, 50, 21, 34]

This function returns the elements of a set in reverse order.

```
var intSet:Set = [21, 22, 23, 24, 25]
print(intSet)
let reversedSet = intSet.reversed()
print(reversedSet)
```

When you run the program, the output will be:

[22, 23, 21, 24, 25] [25, 24, 21, 23, 22]

This property returns the total number of elements in a set.

```
let floatSet:Set = [10.2, 21.3, 32.0, 41.3]
print(floatSet.count)
```

When you run the program, the output will be:

4

This function removes and returns the first value from the set.

```
var strSet:Set = ["ab", "bc", "cd", "de"]
let removedVal = strSet.removeFirst()
print("removed value is \(removedVal)")
print(strSet)
```

When you run the program, the output will be:

removed value is de ["ab", "cd", "bc"]

Similarly, you can also use `removeAll`

function to empty a set.