Método mutableSetOf() de Kotlin

La interfaz Kotlin Set es una colección genérica de elementos desordenados y no contiene elementos duplicados. Kotlin admite dos tipos de conjuntos mutables e inmutables. 
setOf() es inmutable , lo que significa que solo admite funciones de solo lectura y mutableSetOf() es mutable , lo que significa que admite funciones de lectura y escritura. 

Sintaxis: 

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

Descripción:  

• Esta función devuelve un conjunto de elementos dados, que se pueden leer y escribir.
• El conjunto devuelto conserva el orden de iteración del elemento.

Programa Kotlin de la función mutableSetOf() :

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)
}

Producción: 

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

Adición y eliminación de elementos en un conjunto:

Podemos agregar elementos en un conjunto mutable usando la función add() y eliminar elementos usando la función remove().

Ejemplo :  

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)
}

Producción: 

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

Establecer indexación –

Usando las funciones de índice indexOf() , lastIndexOf() podemos obtener el índice del elemento especificado. Y también podemos encontrar los elementos en algún índice específico usando la función elementAt().

Programa Kotlin de uso de índice –  

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"))
}

Producción: 

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

Establecer primer y último elemento –

Podemos obtener el primero y el elemento de un conjunto usando las funciones first() y last(). 

programa kotlin-  

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())
}

Producción: 

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

Recorrido en un conjunto mutable –

Podemos ejecutar un bucle for con un iterador que atraviese todos los elementos del conjunto. 

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 )
}

Producción: 

1
2
3
4

funciones contains() y containsAll() –

Ambos métodos se utilizan para verificar si un elemento está presente en el conjunto o no. 

Programa Kotlin de uso de la función contains() y containsAll() –  

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")))
}

Producción: 

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

Comprobación de la igualdad de los conjuntos vacíos y el uso de las funciones isEmpty() –

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

Esta sintaxis devuelve un conjunto vacío de tipo específico.

Programa de Kotlin para usar la función isEmpty() –  

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
}

Producción : 

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