Learn the fundamentals of a non-ordered, unique collection in Kotlin. 

Sets

Great job! In this lesson, we've learned the following concepts:

-  A set is an unordered Kotlin collection that stores unique elements. 
-  An immutable set is declared with the `setOf` keyword and indicates a set whose values cannot change throughout a program.  
-  A mutable set is declared with the `mutableSetOf` keyword and indicates a set whose values can be altered. 
- Elements within a set can be accessed using the `elementAt()` or `elementAtOrNull()` functions.
- The `addAll()` and `add()` functions are used to add elements to a collection.
- The `first()` and `last()` functions return the first and last elements of a collection. 
- The `clear()` function removes all elements from a collection. 

You've now covered the second major collection that exists in Kotlin as well as many other programming languages. Feel free to utilize the empty **Review.kt** file and output terminal on the right to hone your understanding of sets and practice writing Kotlin code. 

Review

In addition to adding and removing elements from a set, the set collection supports a myriad of other functionalities. You can find the entire list in Kotlin's [documentation](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-set/#functions).  

In this exercise, we'll explore some of the most common set functions using the following example:

```kt
var numbers = setOf(10, 15, 20, 25)
```

To retrieve, the first element of any set, we can use the `first()` function: 

```kt
numbers.first() // 10 
```

To retrieve the last element of any set, we can use the `last()` function: 

```kt 
numbers.last() // 25
```

Finally, if we'd like to sum up all of the elements in a set, we can use the `sum()` function: 

```kt 
numbers.sum() // 70 
```

**Note**: To see the output of each function call on a set, it must be wrapped in a print statement. 

Additional Set Functions 

With immutable sets, we don't have much control over the contents they store, but with mutable sets, we are able to add, remove, or replace as many elements as we'd like. This allows us to work both with sets that are populated with values and empty sets, which are sets that are initialized without any values but can be populated at a later time.

To initialize an empty mutable set, we'd use the following syntax:

```pseudo
var/val setName = mutableSetOf<Type>()
``` 

- The term, `mutableSetOf` is used to declare a mutable set. 
- The term is followed by the type of data that we expect the set to hold and a pair of empty parentheses.

Assume we're developing a program for a building manager who would like to keep track of the apartments they own. Unfortunately, we haven't received the apartment information from them just yet, so we create a mutable set and wait until we can populate it with values:

```kt 
var totalApts = mutableSetOf<String>()
```

While we wait, let's practice declaring a set that comes prepopulated with values. The syntax is as follows: 

```pseudo
var/val setName = mutableSetOf(value1, value2, value3)
``` 

No need to specify the set type here as it will automatically be inferred by the compiler. Let's see an example: 

```kt 
var nycRadioStations = mutableSetOf(106.7, 101.1, 97.1, 103.5) 
```

The compiler will infer `mutableSetOf<Double>` from the code above and will only accept values of type Double within this set going forward.

Creating a Mutable Set 

Unlike lists, a set is an un-ordered collection, thus we can't use square brackets and indices to retrieve its elements. However, a set is an intelligent tool that stores its elements in the order in which each element was inserted.  We can utilize this order along with a function, `elementAt()`, to access and retrieve elements.  

The `elementAt()` function accepts an Integer value and returns the element at that position. This function is useful for collections that do not possess index access.

```pseudo
listName.elementAt(integer) 
```

Assume we're writing a program that keeps track of animals that are no longer on the endangered list: 

```kt 
var nonEndangered = setOf("Louisiana Black Bear", "Northern Brown Kiwi", "Gray Wolf", "Arabian Oryx") 
```

To retrieve the animal, `"Gray Wolf"` , we'd use the following syntax: 

```kt 
nonEndangered.elementAt(2) // Gray Wolf
```

Since Kotlin is a [null safe](https://kotlinlang.org/docs/reference/null-safety.html) language, it encourages developers to avoid `NullPointerException` errors wherever they can by using safer variations of function. 

In the case that an element does not exist at a specified position, our code would throw an error: 

```kt 
nonEndangered.elementAt(5) // Exception error
```

Exception error: 

```error 
Exception in thread "main" java.lang.IndexOutOfBoundsException: Collection doesn't contain element at index 5.
```

To avoid this, we can use the `elementAtOrNull()` function, a safer variation of `elementAt()` to return `null` as opposed to an error when an element does not exist in the set:

```kt 
nonEndangered.elementAtOrNull(5) // null 
```

Accessing Elements in a Set

To add or remove any elements from a set, we must utilize Kotlin's built-in set functions. Luckily, many of these functions can also be applied to other collection types, thus you might recognize some of these syntaxes from a previous lesson. 

To add a single element to a set, we'd use the `add()` function as we did in the lists lesson; however, if we were interested in adding many elements to a set at once, the `addAll()` function would be more appropriate. Note that in contrast to lists, we cannot add an element that already exists in the set.  

Let's take a look at how `addAll()` works. Recall the building example from the previous exercise. The manager got back to us with the following list of apartments: 

```kt 
var aptList = listOf("1A", "1B", "1C", "2A", "2B", "2C", "2C", "1A")  
```

We're ready to populate our empty set, `totalApts`, with these values. With the help of the `addAll()` function, we're able to populate our set with multiple values at once: 

```kt
totalApts.addAll(aptList) 

println(totalApts) // Prints: [1A, 1B, 1C, 2A, 2B, 2C] 
```

Looks like the manager may have accidentally added duplicate apartment numbers. Luckily, the set removed the duplicate elements, and we're left with unique data.   

Oppositely, we can also remove all elements from a collection using the `clear()` function. Assume the building is selling their property and all of the apartments need to be removed from the data set: 

```kt
totalApts.clear()
println(totalApts) // Prints: []
```

`addAll()` and `clear()` are highly useful, quick, and efficient ways of adding or removing large amounts of data from a collection at once. 

Adding and Removing Elements

As previously discussed, Kotlin collections fall under two categories: mutable and immutable, and sets are no exception. An immutable set is declared using the `setOf` keyword and indicates a set whose values cannot change throughout a program:

```pseudo
var/val setName = setOf(val1, val2, val3) 
```

**Note:** Similarly to lists, the set type can be inferred by the compiler or declared in the code. For example, a set comprised of String values would be inferred as a `Set<String>`.

In the code below, we are creating a new set and storing it in the variable, `colorsOftheRainbow`: 

```kt
var colorsOfTheRainbow = setOf("red", "orange", "yellow", "green", "blue", "red")
```

Logging `colorsOfTheRainbow` to the console, notice that there is one less color in the set. The last element, `"red"`, was a duplicate String that the set object recognized and removed:

```kt
println(colorsOfTheRainbow)

// Prints: [red, orange, yellow, green, blue] 
```

🌈 

Creating an Immutable Set 

In this lesson, we'll learn another fundamental Kotlin collection known as a set. A set is an un-ordered collection of unique elements. It's most commonly applicable in programs that work with data sets containing non-duplicate values such as usernames or passwords. Upon creating or adding elements to a set, the set automatically filters out any duplicates and always returns a unique collection. 

As you progress through this lesson, you'll notice that lists and sets are very common in syntax and share a multitude of built-in functions. Their key difference lies in their purpose and behavior in a program. A developer building a program for a subway line's train stops may choose to work with a list since trains often cross paths, whereas a program that stores bank account information would most likely be utilizing a set. 

As we continue exploring other types of collections in Kotlin, keep in mind the similarities and differences between each one you've learned. A good developer doesn't waste time memorizing every syntax in the book, but instead, focuses on understanding what tools are available and how they can be applied to a program.

Codey is exploring the constellations in the night sky: ["Leo", "Aries", "Sagittarius", "Libra"] written in the form of a Kotlin set. 