in

Scala – Mapas


Scala map es una colección de pares clave / valor. Se puede recuperar cualquier valor en función de su clave. Las claves son únicas en el mapa, pero los valores no necesitan ser únicos. Los mapas también se denominan tablas hash. Hay dos tipos de mapas, el inmutable y el mudable. La diferencia entre objetos mutables e inmutables es que cuando un objeto es inmutable, el objeto en sí no se puede cambiar.

De forma predeterminada, Scala usa el mapa inmutable. Si desea utilizar el mapa mutable, tendrá que importar scala.collection.mutable.Map clase explícitamente. Si desea utilizar mapas mutables e inmutables en el mismo, puede continuar refiriéndose al mapa inmutable como Mapa pero puede referirse al conjunto mutable como mutable.Map.

A continuación se muestran las declaraciones de ejemplo para declarar mapas inmutables:

// Empty hash table whose keys are strings and values are integers:
var A:Map[Char,Int] = Map()

// A map with keys and values.
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")

Al definir un mapa vacío, la anotación de tipo es necesaria ya que el sistema necesita asignar un tipo concreto a la variable. Si queremos agregar un par clave-valor a un mapa, podemos usar el operador + de la siguiente manera.

A + = ('I' -> 1)
A + = ('J' -> 5)
A + = ('K' -> 10)
A + = ('L' -> 100)

Operaciones básicas en MAP

Todas las operaciones en mapas se pueden expresar en términos de los siguientes tres métodos.

No Señor Métodos y descripción
1

teclas

Este método devuelve un iterable que contiene cada clave en el mapa.

2

valores

Este método devuelve un iterable que contiene cada valor en el mapa.

3

esta vacio

Este método devuelve verdadero si el mapa está vacío; de lo contrario, es falso.

Pruebe el siguiente programa de ejemplo que muestra el uso de los métodos Map.

Ejemplo

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

      val nums: Map[Int, Int] = Map()

      println( "Keys in colors : " + colors.keys )
      println( "Values in colors : " + colors.values )
      println( "Check if colors is empty : " + colors.isEmpty )
      println( "Check if nums is empty : " + nums.isEmpty )
   }
}

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

>scalac Demo.scala
>scala Demo

Producción

Keys in colors : Set(red, azure, peru)
Values in colors : MapLike(#FF0000, #F0FFFF, #CD853F)
Check if colors is empty : false
Check if nums is empty : true

Concatenación de mapas

Puedes usar cualquiera & plus; & plus; operador o Mapa. ​​& Plus; & plus; () para concatenar dos o más mapas, pero al agregar mapas eliminará las claves duplicadas.

Pruebe el siguiente programa de ejemplo para concatenar dos mapas.

Ejemplo

object Demo {
   def main(args: Array[String]) {
      val colors1 = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")
      val colors2 = Map("blue" -> "#0033FF", "yellow" -> "#FFFF00", "red" -> "#FF0000")

      // use two or more Maps with ++ as operator
      var colors = colors1 ++ colors2
      println( "colors1 ++ colors2 : " + colors )

      // use two maps with ++ as method
      colors = colors1.++(colors2)
      println( "colors1.++(colors2)) : " + colors )
   }
}

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

>scalac Demo.scala
>scala Demo

Producción

colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, 
   peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)

Imprimir claves y valores desde un mapa

Puede iterar a través de las claves y valores de un mapa utilizando el bucle «foreach». Aquí, usamos el método para cada asociado con el iterador para recorrer las claves. A continuación se muestra el programa de ejemplo.

Ejemplo

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF","peru" -> "#CD853F")

      colors.keys.foreach{ i =>  
         print( "Key = " + i )
         println(" Value = " + colors(i) )}
   }
}

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

>scalac Demo.scala
>scala Demo

Producción

Key = red Value = #FF0000
Key = azure Value = #F0FFFF
Key = peru Value = #CD853F

Buscar una clave en el mapa

Puedes usar cualquiera Mapa.contiene método para probar si una clave determinada existe en el mapa o no. Pruebe el siguiente programa de ejemplo para la comprobación de claves.

Ejemplo

object Demo {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F")

      if( colors.contains( "red" )) {
         println("Red key exists with value :"  + colors("red"))
      } else {
           println("Red key does not exist")
      }
      
      if( colors.contains( "maroon" )) {
         println("Maroon key exists with value :"  + colors("maroon"))
      } else {
         println("Maroon key does not exist")
      }
   }
}

Guarde el programa anterior en Demo.scala. Los siguientes comandos se utilizan para compilar y ejecutar este programa.

Mando

>scalac Demo.scala
>scala Demo

Producción

Red key exists with value :#FF0000
Maroon key does not exist

Métodos de Scala Map

A continuación se muestran los métodos importantes que puede utilizar mientras juega con Maps. Para obtener una lista completa de los métodos disponibles, consulte la documentación oficial de Scala.

No Señor Métodos con descripción
1

def & plus; & plus; (xs: Map[(A, B)]): Mapa[A, B]

Devuelve un nuevo mapa que contiene asignaciones de este mapa y las proporcionadas por xs.

2

def – (elem1: A, elem2: A, elems: A *): Mapa[A, B]

Devuelve un nuevo mapa que contiene todas las asignaciones de este mapa excepto las asignaciones con una clave igual a elem1, elem2 o cualquiera de elems.

3

def – (xs: GTO[A]): Mapa[A, B]

Devuelve un nuevo mapa con todas las asignaciones clave / valor de este mapa, excepto las asignaciones con una clave igual a una clave del objeto transitable xs.

4

def get (clave: A): Opción[B]

Opcionalmente devuelve el valor asociado con una clave.

5

def iterador: iterador[(A, B)]

Crea un nuevo iterador sobre todos los pares clave / valor de este mapa

6

def addString (b: StringBuilder): StringBuilder

Agrega todos los elementos de esta colección encogible a un constructor de cuerdas.

7

def addString (b: StringBuilder, sep: String): StringBuilder

Agrega todos los elementos de esta colección encogible a un generador de cadenas usando una cadena de separación.

8

def aplicar (clave: A): B

Devuelve el valor asociado con la clave dada, o el resultado del método predeterminado del mapa, si no existe ninguno.

9

def clear (): Unidad

Elimina todas las vinculaciones del mapa. Una vez finalizada esta operación, el mapa estará vacío.

10

def clone (): Mapa[A, B]

Crea una copia del objeto receptor.

11

def contiene (clave: A): booleano

Devuelve verdadero si hay un enlace para la clave en este mapa, falso en caso contrario.

12

def copyToArray (xs: Array[(A, B)]): Unidad

Copia valores de esta colección encogible en una matriz. Llena la matriz xs dada con valores de esta colección encogible.

13

def count (p: ((A, B)) => Boolean): Int

Cuenta el número de elementos de la colección encogible que satisfacen un predicado.

14

def predeterminado (clave: A): B

Define el cálculo del valor predeterminado para el mapa, devuelto cuando no se encuentra una clave.

15

def drop (n: Int): Mapa[A, B]

Devuelve todos los elementos excepto los primeros n.

dieciséis

def dropRight (n: Int): Mapa[A, B]

Devuelve todos los elementos excepto los n últimos

17

def dropWhile (p: ((A, B)) => Boolean): Mapa[A, B]

Elimina el prefijo más largo de elementos que satisfacen un predicado.

18

def vacío: Mapa[A, B]

Devuelve el mapa vacío del mismo tipo.

19

def es igual a (que: Cualquiera): Booleano

Devuelve verdadero si ambos mapas contienen exactamente las mismas claves / valores, falso en caso contrario.

20

def existe (p: ((A, B)) => Booleano): Booleano

Devuelve verdadero si el predicado p dado se cumple para algunos de los elementos de esta colección encogible; de ​​lo contrario, es falso.

21

def filter (p: ((A, B)) => Booleano): Mapa[A, B]

Devuelve todos los elementos de esta colección encogible que satisfacen un predicado.

22

def filterKeys (p: (A) => Boolean): Mapa[A, B]

Devuelve un mapa inmutable que consta solo de los pares clave-valor de este mapa donde la clave satisface el predicado p.

23

def find (p: ((A, B)) => Boolean): Opción[(A, B)]

Encuentra el primer elemento de la colección encogible que satisface un predicado, si lo hay.

24

def foreach (f: ((A, B)) => Unidad): Unidad

Aplica una función f a todos los elementos de esta colección encogible.

25

def init: Mapa[A, B]

Devuelve todos los elementos excepto el último.

26

def isEmpty: booleano

Comprueba si el mapa está vacío.

27

def keys: Iterable[A]

Devuelve un iterador sobre todas las claves.

28

def último: (A, B)

Devuelve el último elemento.

29

def max: (A, B)

Encuentra el elemento más grande.

30

def min: (A, B)

Encuentra el elemento más pequeño.

31

def mkString: String

Muestra todos los elementos de esta colección encogible en una cadena.

32

producto def: (A, B)

Devuelve el producto de todos los elementos de esta colección encogible con respecto al operador * en num.

33

def remove (clave: A): Opción[B]

Elimina una clave de este mapa, devolviendo el valor asociado previamente con esa clave como una opción.

34

def retener (p: (A, B) => Booleano): Map.this.type

Conserva solo aquellas asignaciones para las que el predicado p devuelve verdadero.

35

def tamaño: Int

Devuelve el número de elementos de este mapa.

36

def suma: (A, B)

Devuelve la suma de todos los elementos de esta colección encogible con respecto al operador + en num.

37

def tail: Mapa[A, B]

Devuelve todos los elementos excepto el primero.

38

def take (n: Int): Mapa[A, B]

Devuelve los primeros n elementos.

39

def takeRight (n: Int): Mapa[A, B]

Devuelve los últimos n elementos.

40

def takeWhile (p: ((A, B)) => Boolean): Mapa[A, B]

Toma el prefijo más largo de elementos que satisfacen un predicado.

41

def toArray: Array[(A, B)]

Convierte esta colección encogible en una matriz.

42

def toBuffer[B >: A]: Buffer[B]

Devuelve un búfer que contiene todos los elementos de este mapa.

43

def toList: Lista[A]

Devuelve una lista que contiene todos los elementos de este mapa.

44

def toSeq: Seq[A]

Devuelve una secuencia que contiene todos los elementos de este mapa.

45

def toSet: Establecer[A]

Devuelve un conjunto que contiene todos los elementos de este mapa.

46

def toString (): Cadena

Devuelve una representación de cadena del objeto.

scala_collections.htm

Deja una respuesta

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

router

Que es el enrutador – javatpoint

apple touch icon@2

html – ¿Cómo obtener un carácter de tabulación?