Escala | métodos para llamar en un mapa | Serie 1

Prerrequisito : Mapa de Scala .

En Scala hay métodos principales para llamar en un mapa . Un método Scala es una sección de una clase que tiene una designación, una firma, opcionalmente algunas anotaciones y cualquier código de bytes. Una función que se interpreta como miembro de algún objeto se denomina método y el método de mapa se incorpora exactamente con colecciones; además, es miembro de un rasgo transitable que es ejecutado por las clases de colección de Scala ( Traversable explica numerosos métodos concretos) .

Los métodos más predominantes para llamar a un mapa de Scala son los siguientes:

• def ++(xs: Map[(A, B)]): Map[A, B]
  Este método se utiliza para concatenar dos o más mapas. En Concatenar Mapas separará las claves idénticas.
  Ejemplo:

  // Scala program to concatenate two Map    // Creating Object object GFG  {     // Main method     def main(args: Array[String])      {            // Creating maps         val group1 = Map("Nidhi" -> 23, "Rahul" -> 18)         val group2 = Map("Geeta" -> 22, "Rahul" -> 18)            // using ++ as a method         val concatenate = group1.++(group2)            // Displays concatenated map         println( "Concatenation is: " + concatenate)     } }

  Producción:

  Concatenation is: Map(Nidhi -> 23, Rahul -> 18, Geeta -> 22)
  

  Aquí, la clave «Rahul» está presente en ambos Mapas, por lo que al Concatenar dos Mapas, se elimina el similar.

• def -(elem1: A, elem2: A, elems: A*): Map[A, B]
  Este método se utiliza para borrar el conjunto de claves presentes en los argumentos. Entonces, devuelve un nuevo mapa que contiene todos los elementos de este Mapa excepto estos argumentos.
  Ejemplo:

  // Scala program to delete keys    // Creating object object GFG {            // Main method     def main(args: Array[String])      {            // Creating mutable map          val m = scala.collection.mutable.Map[String, Int]("Geeta" -> 21, "Nidhi" -> 23)                 // using <b>-</b> as a method         val c = m.-("Geeta")            // Displays a new map         println( "The new Map returns: " + c)     } }

  Producción:

  The new Map returns: Map(Nidhi -> 23)
  

  Por lo tanto, el nuevo mapa contiene solo «Nidhi» y se elimina «Geeta».

• def get(clave: A): Opción[B]
  Este método se utiliza para devolver las claves correspondientes a los valores dados en el método como argumento.
  Ejemplo:

  // Scala program to get values // corresponding to the key    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("Geeta" -> 22, "Rahul" -> 18)            // using 'get' as a method         val x = m.get("Rahul")         val y = n.get("Nidhi")            // Displays key corresponding          // to the given values          println(x)         println(y)     } }

  Producción:

  Some(18)
  None
  

  Aquí, «Rahul» devuelve su valor correspondiente pero «Nidhi» devuelve Ninguno , ya que esta clave no está relacionada con el Mapa dado.

• def iterator: Iterator[(A, B)]
  Este método se utiliza para devolver un iterador.
  Ejemplo:

  // Scala program to return // an iterator    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("sonu" -> 16, "Nisha" -> 21)            // using 'iterator' as a method         val x = m.iterator         val y = n.iterator            // Displays if the iterator         // is empty or not         println(x)         println(y)     } }

  Producción:

  non-empty iterator
  non-empty iterator
  

  Aquí, ambos mapas no están vacíos, por lo que se devuelve un iterador no vacío.

• def addString(b: StringBuilder): StringBuilder
  Este método se utiliza para agregar cada uno de los elementos del Mapa al StringBuilder .
  Ejemplo:

  // Scala program to add the elements // of Map to the StringBuilder    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Nisha" -> 21)         val n = Map("sonu" -> 16, "Rahul" -> 18)            // using 'addString' as a method         val x = m.addString(new StringBuilder())         val y = n.addString(new StringBuilder())               // Displays elements in the         // StringBuilder         println(x)         println(y)     } }

  Producción:

  Nidhi -> 23Nisha -> 21
  sonu -> 16Rahul -> 18
  

  Por lo tanto, los elementos se devuelven en StringBuilder.

• def addString(b: StringBuilder, sep: String): StringBuilder
  Este método agrega elementos del Mapa al StringBuilder y también agrega un separador entre los elementos.
  Ejemplo:

  // Scala program to add the elements // of Map to the StringBuilder and  // also add a separator    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Nisha" -> 21)         val n = Map("sonu" -> 16, "Rahul" -> 18)            // using 'addString' as a method         // and adding a separator to it         val x = m.addString(new StringBuilder(), "_")         val y = n.addString(new StringBuilder(), "_")            // Displays elements in the         // StringBuilder with the          // separator         println(x)         println(y)     } }

  Producción:

  Nidhi -> 23_Nisha -> 21
  sonu -> 16_Rahul -> 18
  

  Por lo tanto, los elementos se devuelven en StringBuilder con un separador.

• def apply(clave: A): B
  Es útil para buscar una clave en el Mapa.
  Ejemplo:

  // Scala program to search  // a key value    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Nisha" -> 21)         val n = Map("sonu" -> 16, "Rahul" -> 18)            // using 'apply' method         val x = m.apply("Nisha")         val y = n.apply("sonu")            // Displays values of          // the key          println(x)         println(y)     } }

  Producción:

  21
  16
  

  Aquí, si la clave buscada no existe, entonces no se encuentra el valor de la clave.

• def clear(): Unidad
  Esto se utiliza para limpiar el Mapa.
  Nota: value clear es miembro de scala.collection.mutable.Map[String, Int].
  Ejemplo:

  // Scala program to clear // the Map    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating mutable map         val n = scala.collection.mutable.Map("Nidhi" -> 23,                                              "Nisha" -> 21)            // using 'clear' method         val x = n.clear()            //Displays empty Map          println(x)     } }

  Producción:

  ()
  

  Aquí, se eliminan las claves de un mapa mutable.

• def clone(): Map[A, B]
  Este método se utiliza para hacer una copia del objeto de los receptores.
  Nota: value clone es miembro de scala.collection.mutable.Map[String, Int].
  Ejemplo:

  // Scala program to make // a copy of the receivers  // object    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating mutable map         val n = scala.collection.mutable.Map("Nidhi" -> 23,                                         "Nisha" -> 21)            // using 'clone' method         val x = n.clone()            // Displays copied keys         println(x)     } }

  Producción:

  Map(Nidhi -> 23, Nisha -> 21)
  

  Aquí, se devuelve una copia del objeto de los receptores.

• def contiene(clave: A): Booleano
  Este método se utiliza para verificar si la clave está presente en el Mapa o no. Si la clave está presente, devuelve verdadero; de lo contrario, devuelve falso.
  Ejemplo:

  // Scala program to check if  // the key is present or not    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("sonu" -> 16, "Nisha" -> 21)            // using 'contains' method         val x = m.contains("Nidhi")         val y = n.contains("Rahul")            // Displays true if the key          // is present else false         println(x)         println(y)     } }

  Producción:

  true
  false
  

  Aquí, «Nidhi» está presente en el mapa, por lo que se devuelve verdadero, pero «Rahul» no está presente en el mapa dado, por lo que devuelve falso.

• def copyToArray(xs: Array[(A, B)]): Unidad
  Este método es útil para copiar un par de claves del Mapa a una array.
  Ejemplo:

  // Scala program to copy keys  // to an Array    // Creating object object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18)            // Creating Array         val x: Array[Any] = Array(0, 0, 0, 0, 0)            // using 'copyToArray' method         m.copyToArray(x)            // Displays keys copied in         // the Array         for(m1 <-x)             println(m1)     } }

  Producción:

  (Nidhi,23)
  (Rahul,18)
  0
  0
  0
  

  Aquí, dos claves del Mapa se copian en el Array.

• def count(p: ((A, B)) => Boolean): Int
  Este método se utiliza para contar un par de claves en el Mapa.
  Ejemplo:

  // Scala program to count // pair of keys in the Map    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18)            // using 'count' method         val y = m.count(z=>true)            // Displays number of keys         // in the Map         println(y)     } }

  Producción:

  2
  

  Aquí, dos claves están presentes en el Mapa, por lo que se devuelven dos.

• def drop(n: Int): Map[A, B]
  Este método se utiliza para borrar los primeros ‘n’ elementos.
  Ejemplo:

  // Scala program to delete // first n elements    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'drop' method         val y = m.drop(2)            // Displays all the elements of          // the map except the first two         // elements         println(y)     } }

  Producción:

  Map(Nisha -> 21, Rohit -> 16)
  

  Aquí, drop(n) es la operación deseada, donde los primeros ‘n’ elementos se eliminan y se devuelve el resto de los elementos.

• def dropRight(n: Int): Map[A, B]
  Este método se utiliza para borrar los últimos ‘n’ elementos.
  Ejemplo:

  // Scala program to delete  // last n elements    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                      "Nisha" -> 21, "Rohit" -> 16)            // using 'dropRight' method         val y = m.dropRight(2)            // Displays all the keys of          // map except the last two         // elements         println(y)     } }

  Producción:

   Map("Nidhi" -> 23, "Rahul" -> 18)
  

  Aquí, dropRight(n) es la operación deseada, donde se eliminan los últimos ‘n’ elementos y se devuelve el resto de los elementos.

• def dropWhile(p: ((A, B)) => Boolean): Map[A, B]
  Esta operación elimina los elementos hasta que se cumple la condición establecida.
  Ejemplo:

  // Scala program to delete the // elements until the stated // condition is satisfied    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'dropWhile' method         val y = m.dropWhile(z=>true)            // Displays empty map         println(y)     } }

  Producción:

   Map()
  

  Aquí, dropWhile es la operación deseada y de acuerdo con la condición dada, se devuelve un Map vacío.

• def vacío: Mapa[A, B]
  Este método se utiliza para devolver un Mapa vacío.
  Ejemplo:

  // Scala program to form // an empty Map    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'empty' method         val y = m.empty            // Displays empty map         println(y)     } }

  Producción:

   Map()
  

• def equals(that: Any): Boolean
  Este método se utiliza para verificar si los dos mapas tienen el mismo par clave-valor.
  Ejemplo:

  // Scala program to check if the // two maps have the same  // number of elements       // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Maps         val m = Map("Nidhi" -> 23, "Rahul" -> 18)         val n = Map("Nisha" -> 21, "Rohit" -> 16)            // using 'equals' method         val y = m.equals(n)            // Displays true if the maps are         // equal else returns false         println(y)     } }

  Producción:

   false
  

  Aquí, el método equals devuelve verdadero si los pares clave-valor de ambos mapas son iguales; de lo contrario, devuelve falso.

• def init: Map[A, B]
  Este método se utiliza para devolver todos los elementos del Mapa excepto el último.
  Ejemplo:

  // Scala program to return // all the elements of the // map except the last one    // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'init' method         val y = m.init            // Displays all the elements         // except the last one         println(y)     } }

  Producción:

   Map(Nidhi -> 23, Rahul -> 18, Nisha -> 21)
  

  Aquí, de los cuatro elementos del Mapa, se devuelven los primeros tres elementos del Mapa.

• def último: (A, B)
  Este método devuelve el último elemento del Mapa.
  Ejemplo:

  // Scala program to find the  // last element       // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating Map         val m = Map("Nidhi" -> 23, "Rahul" -> 18,                     "Nisha" -> 21, "Rohit" -> 16)            // using 'last' method         val y = m.last            // Displays the last element         println(y)     } }

  Producción:

  (Rohit, 16)
  

• def remove(key: A): Option[B]
  Este método elimina la clave y devuelve solo su valor.
  Ejemplo:

  // Scala program to return the // value of the given key       // Creating object  object GFG {        // Main method     def main(args: Array[String])     {            // Creating mutable map         val m = scala.collection.mutable.Map("Nidhi" -> 23,                 "Rahul" -> 18, "Nisha" -> 21, "Rohit" -> 16)            // using 'remove' method         val y = m.remove("Rahul")            // Displays the value associated         // with the key in the argument         println(y)     } }

  Producción:

  some(18)
  

  Nota: El valor eliminar es miembro del mapa mutable.
  Estos fueron los principales métodos de Scala, hay muchos más métodos de este tipo.