Kotlin Sets

Kotlin MutableSet Interface

The MutableSet interface represents a generic unsorted collection of elements. The MutableSet interface does not support duplicate elements. Because this interface is changeable, its methods provide read-write functionality and the addition and removal of items.

MutableSet Interface utilizes the mutableSetOf() function to construct a list of set interface objects containing elements.

Code:

fun main() {
    val mutableSet = mutableSetOf<Int>(1,2,3,4,5,6,7,8,9,10)
    var sum = 0
    for(index in 0 until mutableSet.size){
        val currentItem = mutableSet.elementAt(index)
        sum += currentItem
    }
    println(sum)
 }

Output:

55

We are using mutableSetOf() instead of setOf() so that we can use add() and remove() functions on sets. We are explicitly defining the mutable set of Integer type.

We are using a for loop to iterate through each set item. Note If you want to know how this for loops works, please go to this article.

size() will return the total number of items in this set. The currentItem variable contains the current element of the present iteration of our loop. The elementAt() will return an element situated at the provided index. Finally, we add this item to our sum variable and print it.

Functions of MutableSet Interface

MutableSet contains all the functions of Set Interface which some additional functions like addAll() or removeAll().

Code:

fun main() {
    val mutableSet = mutableSetOf<Int>(1,2,3,4,5,6,7,8,9,10)
    val tempSet = mutableSetOf<Int>()
    tempSet.addAll(mutableSet) // adding mutableSet content to tempSet
    for(item in mutableSet){
        if(item % 2 == 0){
            // adding even number to tempSet
            tempSet.add(item)
        } else {
            // removing odd number from tempSet
            tempSet.remove(item)
        }
    }
    println(tempSet) // only contains non duplicate elements
    println(tempSet.indexOf(8)) // return the current index of element 8
    tempSet.removeAll(setOf(2,3,5,7,9)) // remove prime numbers from tempSet
    println(tempSet.any()) // if set contains at least one element
    println(tempSet) // content after the remove operation
    tempSet.clear()
    println("does tempSet contain any element ${tempSet.any()}, content of tempSet is $tempSet") // content after the clear operation
    println("original content of tempSet was $mutableSet")
 }

Output:

[2, 4, 6, 8, 10]
3
true
[4, 6, 8, 10]
does tempSet contain any element false, content of tempSet is []
original content of tempSet was [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

We have created an empty set in tempSet variable. By using addAll(), we added the contents of mutableSet to tempSet, and it returns a boolean depending upon the success of the insert operation.

We are using a for each loop to iterate over every element. If the current element is even, then we are adding this element to tempSet else, we are removing the element from tempSet.

indexOf() returns the index of supplied element.If the supplied element is not found then this function will return -1.

Like addAll(), removeAll() removes the List supplied to it from the tempSet and returned a boolean depending upon the success of the remove operation. clear() works the same way, but it removes all the elements from the tempSet. Finally, any() will check if the tempSet contains any element and return a boolean.

Kotlin HashSet Class

HashSet is a collection class that extends AbstractMutableSet and implements the Set interface, which uses a hashing mechanism to store elements. It supports both read and write operations. It does not handle duplicate values and does not assure element order sequencing.

Code:

fun main() {
    val hashSet = HashSet<Int>(5)
    val tempSet: HashSet<String> = hashSetOf()
 
    for (i in 0 until 5){
        hashSet.add(i)
    }
 
    for(index in 0 until hashSet.size){
        val current = hashSet.elementAt(index)
        tempSet.add("$current'")
    }
    println(hashSet) // Integer hashSet
    println(tempSet) // String tempSet
 }

Output:

[0, 1, 2, 3, 4]
[4', 3', 2', 1', 0']

hashSet variable has been defined by supplying its capacity during compile time. Variable tempSet has been initialized with no value.

We are iterating over each element to add every element from hashSet to tempSet. And finally, we are printing both variables.

Functions of HashSet Class

As HashSet implements the Set interface, it covers all the significant functions of the set. The above functions and their example can also be applied to HashSet. 

We can use add(), contains(), isEmpty(), remove(), clear() similarly in HashSet.

FAQs

1. Is Set a list?
   A list is an ordered list of elements, whereas a set is an unordered list.
    
2. Which is better, List or Set?
   Set is your best bet if you only need unique values, but List is the ideal option if elements keep the insertion order regardless of duplication.
    
3. What is the difference between HashSet and HashMap?
   Because HashSet does not allow duplicate items, you cannot store identical values in it. Also, It accepts a single null value. Whereas, HashMap does not allow duplicate keys but does allow similar values. It allows for a single null key and unlimited null values.

Key Takeaways

Cheers if you reached here!! 

The purpose of this article was to introduce you to the Kotlin Sets, the basic syntax of implementing this, and understand the basic core concept about Sets, MutableSet, HashSet in Android Development.

If you want to learn more about Lamdas Expression in Kotlin, you can jump to this article which covers them in great detail.

Check out this problem - Duplicate Subtree In Binary Tree

However, learning never stops, and there is more to learn. So head over to our Android Development Course on the Coding Ninjas Website to dive deep into Android Development and build future applications. Till then, Happy Learning!