Kotlin Set interface is a generic unordered collection of elements and it does not contain duplicate elements. Kotlin supports two types of sets mutable and immutable.
setOf() is immutable means it supports only read-only functionalities and mutableSetOf() is mutable means it supports read and write both functionality.
Syntax:
fun <T> mutableSetOf( vararg elements: T): MutableSet<T>
Description:
- This function returns a set of given elements, which can be both read and written.
- The returned set preserves the element iteration order.
Kotlin program of mutableSetOf() function :
fun main(args: Array<String>) { //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(args: Array<String>) { //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]
Set Indexing –
Using index functions indexOf() , lastIndexOf() we can get the index of the specified element. And we can also find the elements at some specific index using elementAt() function.
Kotlin program of using index –
fun main(args: Array<String>) { 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
Set first and last element –
We can get the first and element of a set using first() and last() functions.
Kotlin program –
fun main(args: Array<String>){ 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
Traversal in a mutableSet –
We can run a for loop with an iterator which traverse all the items in the set .
fun main(args: Array<String>) { //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
contains() and containsAll() functions –
Both the methods are used to check whether an element is present in the set or not?
Kotlin program of using contains() and containsAll() function –
fun main(args: Array<String>){ 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
Checking equality of empty sets and use of isEmpty() functions –
fun <T> mutableSetOf(): mutableSet<T>
This syntax returns an empty set of specific type.
Kotlin program of using isEmpty() function –
fun main(args: Array<String>) { //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 []
Sure, here’s an example of using the mutableSetOf() function to create a set of fruits and then adding, removing, and iterating over the elements of the set:
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():
- 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.
- 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.
- 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():
- 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.
- 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.