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.

## What is a set?

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.

## How to declare a set in Swift?

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

### Example 1: Declaring an empty set

`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:

### Example 2: Declaring a set with some values

```
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.

### Example 3: Declaring a set with duplicate values

```
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*.

## How to access set elements in Swift?

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.

#### Example 4: Accessing elements of a set

```
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:

#### Example 5: Accessing elements of a set using remove()

```
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.

#### Example 6: Optional handling for remove()

```
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"]

## How to add new element in a set?

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

method in Swift.

### Example 7: Add new element using insert()

```
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.

## Set Operations

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.

### 1. Union

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]

### 2. Intersection

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.

### 3. Subtracting

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]**.

### 4. Symmetric Difference

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]**.

## Set Membership and Equality Operations

### Set Equality

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.

#### Example 5: Set equality operations

```
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

### Set membership

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.

#### Example 6: Set membership operations

```
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.

## Some helpful built in Set functions & properties

### 1. isEmpty

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

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

.

#### Example 7: How isEmpty works?

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

When you run the program, the output will be:

false

### 2. first

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

#### Example 8: How first works?

```
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.

### 3. insert

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

#### Example 9: How insert works?

```
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]

### 4. reversed

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

#### Example 10: How reversed() works?

```
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]

### 5. count

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

#### Example 11: How count works?

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

When you run the program, the output will be:

4

### 6. removeFirst

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

#### Example 12: How removeFirst works?

```
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.