Mapa de Scala

Posted on by Rudeus Greyrat

El mapa es una colección de pares clave-valor. En otras palabras, es similar al diccionario. Las claves siempre son únicas, mientras que los valores no necesitan ser únicos. Los pares clave-valor pueden tener cualquier tipo de datos. Sin embargo, el tipo de datos que se usa una vez para cualquier clave y valor debe ser coherente en todo momento. Los mapas se clasifican en dos tipos: mutables e inmutables . Por defecto, Scala usa Map inmutable. Para usar el mapa mutable, debemos importar la clase scala.collection.mutable.Map explícitamente.

Cómo crear mapas de Scala

Los mapas se pueden crear de diferentes maneras según nuestros requisitos y la naturaleza del mapa. Tenemos una sintaxis diferente dependiendo de si el Mapa es mutable o inmutable.

Sintaxis:

// Immutable
variable = Map(key_1 -> value_1, key_2 -> value_2,
 key_3 -> value_3, ....)

// Mutable
variable = scala.collection.mutable.Map(key_1 -> value_1, 
key_2 -> value_2, key_3 -> value_3, ....)

 

Operaciones en un mapa de Scala

Hay tres operaciones básicas que podemos realizar sobre un Mapa:

  1. claves: en Scala Map, este método devuelve un iterable que contiene cada clave en el mapa.
  2. valores: el método de valor devuelve un iterable que contiene cada valor en el mapa de Scala.
  3. isEmpty: este método de mapa de Scala devuelve verdadero si el mapa está vacío; de lo contrario, devuelve falso.

    4.  

    Acceder a valores usando teclas

    Se puede acceder a los valores utilizando el nombre y la clave de la variable Map.
    Ejemplo:

    // Scala map program of 
    // Accessing Values Using Keys
      
    // Creating object 
    object GFG
    {
        // Main method
        def main(args:Array[String])
        {
      
            val mapIm = Map("Ajay" -> 30, 
                            "Bhavesh" -> 20,
                            "Charlie" -> 50)
      
            // Accessing score of Ajay
            val ajay = mapIm("Ajay") 
            println(ajay)
        }
    } 

    Producción:

    30

    Si intentamos acceder al valor asociado con la clave «Juan», obtendremos un error porque dicha clave no está presente en el Mapa. Por lo tanto, se recomienda usar la función contains() al acceder a cualquier valor usando la tecla.
    Esta función busca la clave en el Mapa. Si la clave está presente, devuelve verdadero, de lo contrario, falso.

    // Scala map program of 
    // Accessing Values Using 
    // Keys by contains() function
      
    // Creating object
    object GFG
    {
          
        // Main methode
        def main(args:Array[String])
        {
            val mapIm = Map("Ajay" -> 30,
                            "Bhavesh" -> 20,
                            "Charlie" -> 50)
              
            // the key check in the Map
            val ajay = if(mapIm.contains("Ajay"))
                            mapIm("Ajay") else 0
                              
            val john = if(mapIm.contains("John"))
                            mapIm("John") else 0
      
            println("Ajay:" + ajay)
            println("John:" + john)
        }
    } 

    Producción:

    Ajay:30 
John:0

     

    Actualizando los valores

    Si intentamos actualizar el valor de un mapa inmutable, Scala genera un error. Por otro lado, se acepta cualquier cambio realizado en el valor de cualquier clave en caso de Mapas mutables.
    Ejemplo:
    Actualización del mapa inmutable:

    // Scala map program of 
    // Updating the values
    // in immutable map
      
    // Creating an object
    object GFG
    {
        // Main method
        def main(args:Array[String])
        {
      
            val mapIm = Map("Ajay" -> 30, 
                            "Bhavesh" -> 20, 
                            "Charlie" -> 50)
                  
            println(mapIm)
              
            //Updating
            mapIm("Ajay") = 10 
      
            println(mapIm)
      
        }
    }

    Producción:

    error: la actualización del valor no es miembro de scala.collection.immutable.Map[String, Int]

     
    Actualización del mapa mutable:

    // Scala map program of 
    // Updating the values
    // in mutable map
      
    // Creating Object
    object GFG
    {
          
        // Main method
        def main(args:Array[String])
        {
      
            val mapMut = scala.collection.mutable.Map("Ajay" -> 30,
                                                      "Bhavesh" -> 20, 
                                                      "Charlie" -> 50)
            println("Before Updating: " + mapMut)
      
            // Updating
            mapMut("Ajay") = 10 
      
            println("After Updating: " + mapMut)
        }
    }

    Producción:

    Antes de actualizar: Mapa (Ajay -> 30, Charlie -> 50, Bhavesh -> 20)
    Después de actualizar: Mapa (Ajay -> 10, Charlie -> 50, Bhavesh -> 20)

    Adición de un nuevo par clave-valor

    Podemos insertar nuevos pares clave-valor en un mapa mutable usando el operador += seguido de nuevos pares para agregar o actualizar.
    Ejemplo:

    // Scala map program of 
    // Adding new key-value pair
      
    // Creating object
    object GFG
    {
          
        // Main method
        def main(args:Array[String])
        {
      
            val mapMut = scala.collection.mutable.Map("Ajay" -> 30, 
                                                      "Bhavesh" -> 20,
                                                      "Charlie" -> 50)
      
            println("Before Adding: "+mapMut)
      
            // Adding a new key "Dinesh" and 
            // updating an existing key "Ajay"
            mapMut += ("Ajay" -> 10, "Dinesh" -> 60)
      
            println("After Adding: "+mapMut)
        }
    }

    Producción:

    Antes de agregar: Mapa (Ajay -> 30, Charlie -> 50, Bhavesh -> 20)
    Después de agregar: Mapa (Ajay -> 10, Dinesh -> 60, Charlie -> 50, Bhavesh -> 20)

    Eliminar un par clave-valor:

    Eliminar un par clave-valor es similar a agregar una nueva entrada. La diferencia es que en lugar de += usamos el operador -= seguido de las claves que se eliminarán.
    Ejemplo:

    // Scala map program of 
    // Deleting new key-value pair
      
    // Creating object
    object GFG
    {
          
        // Main method
        def main(args:Array[String])
        {
      
            val mapMut = scala.collection.mutable.Map("Ajay" -> 30,
                                                      "Bhavesh" -> 20,
                                                      "Charlie" -> 50)
      
            println("Before Deleting: "+mapMut)
      
            // Deleting key-value pairs with
            // keys "Ajay" and "Charlie"
            mapMut -= ("Ajay", "Charlie")
      
            println("After Deleting: " + mapMut)
        }
    }

    Producción:

    Antes de eliminar: Mapa (Ajay -> 30, Charlie -> 50, Bhavesh -> 20)
    Después de eliminar: Mapa (Bhavesh -> 20)

    Iteración en un mapa

    El par clave-valor corresponde a una tupla con dos elementos. Por lo tanto, mientras se realiza la iteración, la variable del bucle debe ser un par.
    Para comprender la sintaxis y el funcionamiento de los bucles en Scala, consulte: Bucles|
    Ejemplo de Scala:

    // Scala map program of 
    // Iteration in a Map
      
    // Creating object
    object GFG
    {
          
        // Main method
        def main(args:Array[String])
        {
      
            val mapMut = scala.collection.mutable.Map("Ajay" -> 30,
                                                      "Bhavesh" -> 20,
                                                      "Charlie" -> 50)
      
            // (k, v) is a tuple with two elements
            for((k, v) <- mapMut) 
            {    
                //where k is key and v is value
                print("Key:"+k+", ")
                println("Value:"+v)
            }
        }
    }

    Producción:

    Key:Ajay, Value:30
Key:Charlie, Value:50
Key:Bhavesh, Value:20

     

    Mapa vacío

    En Scala Map, también podemos crear un Mapa vacío y luego agregarle elementos.
    Ejemplo:

    // Scala map program of 
    // Empty Map
      
    // Creating object
    object GFG
    {
          
        // Main method
        def main(args:Array[String])
        {
      
            // Creation of Map having key-value
            // pairs of type (String, Int)
            val mapMut = scala.collection.mutable.Map[String, Int]()
      
            println("Empty Map: " + mapMut)
      
            // Adding new entry
            mapMut += ("Charlie" -> 50) 
      
             println("New Entry: " + mapMut)
        }
    }

    Producción:

    Empty Map: Map()
New Entry: Map(Charlie -> 50)

Publicación traducida automáticamente

Artículo escrito por MohammadKhalid y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *