Kotlin mutableSetOf() method

In Kotlin, a Set is a generic unordered collection of elements that does not allow duplicate elements. Kotlin provides two main types of sets:

1. Immutable Set: Created using setOf() – supports only read-only operations.
2. Mutable Set: Created using mutableSetOf() – supports both read and write operations.

In this article, we are going to learn about mutable set, i.e., mutableSetOf().

To learn about Immutable set, refer to Kotlin Set : setOf()

Syntax: 

fun <T> mutableSetOf(vararg elements: T): MutableSet<T>

Description:  

The mutableSetOf() function returns a mutable set containing the specified elements. The elements can be read, added, or removed. The order of elements is preserved during iteration.

Example of mutableSetOf() function :

fun main() {
    //declaring a mutable set of integers
    val mutableSetA = mutableSetOf<Int>( 1 , 2 , 3 , 4 , 3);
    println(mutableSetA)

    //declaring a mutable set of strings
    val mutableSetB = mutableSetOf<String>("Geeks","for" , "geeks");
    println(mutableSetB)

    //declaring an empty mutable set of integers
    val mutableSetC = mutableSetOf<Int>()
    println(mutableSetC)
}

Output: 

[1, 2, 3, 4]
[Geeks, for, geeks]
[]

Adding and removing elements in a set -

We can add elements in a mutable set using the add() function, and remove an elements using remove () function.

Example :  

fun main() { 
    //declaring a mutable set of integers
    val seta = mutableSetOf( 1 , 2 , 3 , 4 , 3);
    println(seta);
    //adding elements 6 & 7
    seta.add(6);
    seta.add(7);
    println(seta);
     
    //removing 3 from the set
    seta.remove(3);
    println(seta);
     
    //another way to add elements is by using listOf() function
    seta += listOf(8,9)
    println(seta) 
} 

Output: 

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

Accessing Elements by Index -

Though sets are unordered, Kotlin provides some functions for index-based access:

1. elementAt(index)
2. indexOf(element)
3. lastIndexOf(element)

Example of using index –  

fun main() {
    val captains = mutableSetOf("Kohli","Smith","Root","Malinga","Rohit","Dhawan")
    println("The element at index 2 is: "+captains.elementAt(2))
    println("The index of element is: "+captains.indexOf("Smith"))
    println("The last index of element is: "+captains.lastIndexOf("Rohit"))
}

Output: 

The element at index 2 is: Root
The index of element is: 1
The last index of element is: 4

Accessing First and Last Elements –

We can get the first and element of a set using first() and last() functions. 

Example –  

fun main() {
    val captains = mutableSetOf(1,2,3,4,"Kohli","Smith","Root","Malinga","Dhawan","Rohit")
    println("The first element of the set is: "+captains.first())
    println("The last element of the set is: "+captains.last())
}

Output: 

The first element of the set is: 1
The last element of the set is: Dhawan 

Traversing a Mutable Set -

We can iterate over a mutable set using a for loop:

fun main() { 
    //declaring a mutable set of integers
    val seta = mutableSetOf( 1 , 2 , 3 , 4 , 3);
 
    //traversal of seta using an iterator 'item'
    for (item in seta) {
        println( item )
    }
} 

Output: 

1
2
3
4

Checking for Elements –

We can use contains() and containsAll() to verify presence of elements:

Example of using contains() and containsAll() function –  

fun main(){ 
    val captains = mutableSetOf(1,2,3,4,"Kohli","Smith", "Root","Malinga","Rohit","Dhawan") 
  
    var name = "Dhawan"
    println("The set contains the element $name or not?" + "   "+captains.contains(name)) 
  
    var num = 5
    println("The set contains the element $num or not?" + "   "+captains.contains(num)) 
    println("The set contains the given elements or not?" + "   "+captains.containsAll(setOf(1,3,"Root"))) 
} 

Output: 

The set contains the element Dhawan or not?   true
The set contains the element 5 or not?   false
The set contains the given elements or not?   true

Working with Empty Sets and isEmpty() -

fun <T> mutableSetOf(): mutableSet<T>

This syntax returns an empty set of specific type.

Example of using isEmpty() function -  

fun main() {
    //creating an empty set of strings
    val seta = mutableSetOf<String>()
    //creating an empty set of integers
    val setb = mutableSetOf<Int>()
 
    //checking if set is empty or not
    println("seta.isEmpty() is ${seta.isEmpty()}")
 
    // Since Empty sets are equal
 
    //checking if two sets are equal or not
    println("seta == setb is ${seta == setb}")
 
    println(seta) //printing first set
}

Output : 

seta.isEmpty() is true
seta == setb is true
[]

Full Example Demonstrating mutableSetOf() -

fun main() {
    // Create a mutable set of fruits
    val fruits = mutableSetOf("apple", "banana", "cherry")
    
    // Add a new fruit to the set
    fruits.add("orange")
    println("Fruits after adding orange: $fruits")
    
    // Remove a fruit from the set
    fruits.remove("banana")
    println("Fruits after removing banana: $fruits")
    
    // Check if the set contains a particular fruit
    val hasApple = fruits.contains("apple")
    val hasMango = fruits.contains("mango")
    println("Fruits contains apple: $hasApple")
    println("Fruits contains mango: $hasMango")
    
    // Iterate over the elements of the set
    println("Fruits:")
    for (fruit in fruits) {
        println("- $fruit")
    }
}

Output:

Fruits after adding orange: [apple, banana, cherry, orange]
Fruits after removing banana: [apple, cherry, orange]
Fruits contains apple: true
Fruits contains mango: false
Fruits:
- apple
- cherry
- orange

Advantages of mutableSetOf():

1. It allows the programmer to create a set of mutable objects, which can be modified later as needed. This is particularly useful when dealing with dynamic data, where the size and content of the set can change at runtime.
2. It provides efficient performance for adding, removing, and checking if an element is present in the set. The mutableSetOf() function internally uses a hash table to store the elements, which ensures that these operations are O(1) time complexity on average.
3. It provides easy-to-use methods to modify the set, such as add(), remove(), and clear(), which make it simple to add or remove elements from the set as needed.

Disadvantages of mutableSetOf():

1. The hash table used by the mutableSetOf() function can result in slightly slower performance than an ArrayList when iterating over the elements of the set. This is because the hash table does not maintain a particular order of the elements.
2. Since mutableSetOf() creates a mutable set, there is a risk of unintentionally modifying the set from different parts of the code, which can result in unexpected behavior. This can be avoided by ensuring that the mutable set is properly encapsulated and accessed only through the appropriate methods.