Scala Map (mapeo)
Colecciones de ScalaUn Map (mapeo) es una estructura iterable de pares clave/valor (key/value).
Todos los valores pueden obtenerse a través de la clave.
Las claves en un Map son únicas.
Un Map también se denomina tabla hash (Hash table).
Hay dos tipos de Map: mutable e inmutable. La diferencia es que un objeto mutable puede modificarse, mientras que un objeto inmutable no.
Por defecto, Scala utiliza Map inmutables. Si necesita usar colecciones mutables, debe importarlas explícitamente.import scala.collection.mutable.MapClase
En Scala, puede usar tanto Map mutables como inmutables. Para los inmutables se usa directamente Map, y para los mutables se usa mutable.Map. El siguiente ejemplo demuestra la aplicación de un Map inmutable:
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
Al definir un Map, es necesario definir el tipo para los pares clave-valor. Si necesita agregar un par key-value, puede usar el signo +, como se muestra a continuación:
A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)
Operaciones básicas de Map
Scala Map tiene tres operaciones básicas:
| Método | Descripción |
|---|---|
| keys | Devuelve todas las claves (keys) del Map |
| values | Devuelve todos los valores (values) del Map |
| isEmpty | Devuelve true cuando el Map está vacío |
Ejemplo
El siguiente ejemplo demuestra la aplicación básica de los tres métodos anteriores:
Ejemplo
def main(args: Array[String]) {
val colors = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()
println( Las claves en colors son: + colors.keys )
println( Los valores en colors son: + colors.values )
println( Comprobar si colors está vacío: + colors.isEmpty )
println( Comprobar si nums está vacío: + nums.isEmpty )
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test colors 中的键为 : Set(red, azure, peru) colors 中的值为 : MapLike(#FF0000, #F0FFFF, #CD853F) 检测 colors 是否为空 : false 检测 nums 是否为空 : true
Fusión de Map
Puede usar++el operador oMap.++()método para concatenar dos Map. Al fusionar Map, se eliminan las claves duplicadas. A continuación se muestra un ejemplo de fusión de dos Map:
Ejemplo
def main(args: Array[String]) {
val colors1 = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val colors2 = Map("blue" -> "#0033FF",
"yellow" -> "#FFFF00",
"red" -> "#FF0000")
// ++ como operador
var colors = colors1 ++ colors2
println( "colors1 ++ colors2 : " + colors )
// ++ como método
colors = colors1.++(colors2)
println( "colors1.++(colors2) : " + colors )
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test 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)
Mostrar las claves (keys) y valores (values) de un Map
A continuación, mediante un bucle foreach, se muestran las claves (keys) y valores (values) del Map:
Ejemplo
def main(args: Array[String]) {
val sites = Map("ejemplo" -> "http://www.example.com",
"baidu" -> "http://www.baidu.com",
"taobao" -> "http://www.taobao.com")
sites.keys.foreach{ i =>
print( "Key = " + i )
println(" Value = " + sites(i) )}
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test Key = ejemplo Value = http://www.example.com Key = baidu Value = http://www.baidu.com Key = taobao Value = http://www.taobao.com
Comprobar si existe una clave especificada en el Map
Puede usarMap.containsmétodo para comprobar si existe una clave especificada en el Map. Ejemplo:
Ejemplo
def main(args: Array[String]) {
val sites = Map("ejemplo" -> "http://www.example.com",
"baidu" -> "http://www.baidu.com",
"taobao" -> "http://www.taobao.com")
if( sites.contains( "ejemplo" )){
println(La clave ejemplo existe, su valor correspondiente es: + sites("ejemplo"))
}else{
println(La clave ejemplo no existe)
}
if( sites.contains( "baidu" )){
println(La clave baidu existe, su valor correspondiente es: + sites("baidu"))
}else{
println(La clave baidu no existe)
}
if( sites.contains( "google" )){
println(La clave google existe, su valor correspondiente es: + sites("google"))
}else{
println(La clave google no existe)
}
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test ejemplo 键存在，对应的值为 :http://www.example.com baidu 键存在，对应的值为 :http://www.baidu.com google 键不存在
Métodos de Scala Map
La siguiente tabla enumera los métodos comunes de Scala Map:
| N.º | Método y descripción |
|---|---|
| 1 |
def ++(xs: Map[(A, B)]): Map[A, B] Devuelve un nuevo Map, compuesto por el nuevo Map xs |
| 2 |
def -(elem1: A, elem2: A, elems: A*): Map[A, B] Devuelve un nuevo Map, eliminando las claves elem1, elem2 u otros elems. |
| 3 |
def --(xs: GTO[A]): Map[A, B] Devuelve un nuevo Map, eliminando las claves correspondientes del objeto xs. |
| 4 |
def get(key: A): Option[B] Devuelve el valor de la clave especificada |
| 5 |
def iterator: Iterator[(A, B)] Crea un nuevo iterador y genera pares clave/valor |
| 6 |
def addString(b: StringBuilder): StringBuilder Agrega todos los elementos del Map a un StringBuilder, puede incluir separadores |
| 7 |
def addString(b: StringBuilder, sep: String): StringBuilder Agrega todos los elementos del Map a un StringBuilder, puede incluir separadores |
| 8 |
def apply(key: A): B Devuelve el valor de la clave especificada; si no existe, devuelve el valor predeterminado del Map |
| 9 |
def clear(): Unit Vaciar el Map |
| 10 |
def clone(): Map[A, B] Copiar de un Map a otro Map |
| 11 |
def contains(key: A): Boolean Si la clave especificada existe en el Map, devuelve true; de lo contrario, devuelve false. |
| 12 |
def copyToArray(xs: Array[(A, B)]): Unit Copia la colección a un array |
| 13 |
def count(p: ((A, B)) => Boolean): Int Cuenta el número de elementos de la colección que cumplen la condición especificada |
| 14 |
def default(key: A): B Define el valor predeterminado del Map, que se devuelve cuando la clave no existe. |
| 15 |
def drop(n: Int): Map[A, B] Devuelve una nueva colección después de descartar los primeros n elementos |
| 16 |
def dropRight(n: Int): Map[A, B] Devuelve una nueva colección después de descartar los últimos n elementos |
| 17 |
def dropWhile(p: ((A, B)) => Boolean): Map[A, B] Descarta elementos de izquierda a derecha hasta que la condición p no se cumpla |
| 18 |
def empty: Map[A, B] Devuelve un Map vacío del mismo tipo |
| 19 |
def equals(that: Any): Boolean Si dos Map son iguales (tanto claves como valores), devuelve true; de lo contrario, devuelve false |
| 20 |
def exists(p: ((A, B)) => Boolean): Boolean Determina si existe algún elemento en la colección que cumpla la condición especificada |
| 21 |
def filter(p: ((A, B))=> Boolean): Map[A, B] Devuelve todas las colecciones que cumplen la condición especificada |
| 22 |
def filterKeys(p: (A) => Boolean): Map[A, B] Devuelve un Map inmutable que cumple la condición especificada |
| 23 |
def find(p: ((A, B)) => Boolean): Option[(A, B)] Busca el primer elemento de la colección que cumpla la condición especificada |
| 24 |
def foreach(f: ((A, B)) => Unit): Unit Aplica la función a todos los elementos de la colección |
| 25 |
def init: Map[A, B] Devuelve todos los elementos excepto el último |
| 26 |
def isEmpty: Boolean Comprueba si el Map está vacío |
| 27 |
def keys: Iterable[A] Devuelve todas las claves (key)/p> |
| 28 |
def last: (A, B) Devuelve el último elemento |
| 29 |
def max: (A, B) Busca el elemento máximo |
| 30 |
def min: (A, B) Busca el elemento mínimo |
| 31 |
def mkString: String Muestra todos los elementos de la colección como una cadena |
| 32 |
def product: (A, B) Devuelve el producto de los elementos numéricos de la colección. |
| 33 |
def remove(key: A): Option[B] Elimina la clave especificada |
| 34 |
def retain(p: (A, B) => Boolean): Map.this.type Devuelve true si cumple la condición especificada |
| 35 |
def size: Int Devuelve el número de elementos del Map |
| 36 |
def sum: (A, B) Devuelve la suma de todos los elementos numéricos de la colección |
| 37 |
def tail: Map[A, B] Devuelve una colección con todos los elementos excepto el primero |
| 38 |
def take(n: Int): Map[A, B] Devuelve los primeros n elementos |
| 39 |
def takeRight(n: Int): Map[A, B] Devuelve los últimos n elementos |
| 40 |
def takeWhile(p: ((A, B)) => Boolean): Map[A, B] Devuelve los elementos que cumplen la condición especificada |
| 41 |
def toArray: Array[(A, B)] Convierte la colección a un array |
| 42 |
def toBuffer[B >: A]: Buffer[B] Devuelve un buffer que contiene todos los elementos del Map |
| 43 |
def toList: List[A] Devuelve una List que contiene todos los elementos del Map |
| 44 |
def toSeq: Seq[A] Devuelve una Seq que contiene todos los elementos del Map |
| 45 |
def toSet: Set[A] Devuelve un Set que contiene todos los elementos del Map |
| 46 |
def toString(): String Devuelve un objeto String |
Para más métodos, consultela documentación de la API
Otras extensiones