Scala Map
Collections ScalaUne Map est une structure clé/valeur itérable.
Toutes les valeurs peuvent être obtenues via les clés.
Les clés dans une Map sont uniques.
Une Map est aussi appelée table de hachage.
Map a deux types : mutable et immuable. La différence est que les objets mutables peuvent être modifiés, tandis que les objets immuables ne peuvent pas l'être.
Par défaut, Scala utilise une Map immuable. Si vous devez utiliser une collection mutable, vous devez explicitement importerimport scala.collection.mutable.MapClasse
En Scala, vous pouvez utiliser à la fois des Maps mutables et immuables. Pour les immuables, utilisez directement Map ; pour les mutables, utilisez mutable.Map. L'exemple suivant illustre l'application d'une Map immuable :
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
Lors de la définition d'une Map, vous devez définir les types des paires clé-valeur. Si vous devez ajouter des paires clé-valeur, vous pouvez utiliser le signe +, comme indiqué ci-dessous :
A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)
Opérations de base sur les Map
La Map Scala a trois opérations de base :
| Méthode | Description |
|---|---|
| keys | Renvoie toutes les clés de la Map |
| values | Renvoie toutes les valeurs de la Map |
| isEmpty | Renvoie true lorsque la Map est vide |
Exemple
L'exemple suivant illustre l'application de base des trois méthodes ci-dessus :
Exemple
def main(args: Array[String]) {
val colors = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()
println( "Les clés dans colors sont : " + colors.keys )
println( "Les valeurs dans colors sont : " + colors.values )
println( "Vérifier si colors est vide : " + colors.isEmpty )
println( "Vérifier si nums est vide : " + nums.isEmpty )
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test colors 中的键为 : Set(red, azure, peru) colors 中的值为 : MapLike(#FF0000, #F0FFFF, #CD853F) 检测 colors 是否为空 : false 检测 nums 是否为空 : true
Fusion de Map
Vous pouvez utiliser++l'opérateur ouMap.++()la méthode pour concaténer deux Maps. Lorsque des Maps sont fusionnées, les clés en double sont supprimées. Ce qui suit montre un exemple de fusion de deux Maps :
Exemple
def main(args: Array[String]) {
val colors1 = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val colors2 = Map("blue" -> "#0033FF",
"yellow" -> "#FFFF00",
"red" -> "#FF0000")
// ++ en tant qu'opérateur
var colors = colors1 ++ colors2
println( "colors1 ++ colors2 : " + colors )
// ++ en tant que méthode
colors = colors1.++(colors2)
println( \"colors1.++(colors2) : \" + colors )
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ 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)
Afficher les clés et les valeurs d'une Map
Ce qui suit utilise une boucle foreach pour afficher les clés et les valeurs dans une Map :
Exemple
def main(args: Array[String]) {
val sites = Map(\"example\" -> \"http://www.example.com\",
\"baidu\" -> \"http://www.baidu.com\",
\"taobao\" -> \"http://www.taobao.com\")
sites.keys.foreach{ i =>
print( \"Clé = \" + i )
println(\" Valeur = \" + sites(i) )}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test Key = example Value = http://www.example.com Key = baidu Value = http://www.baidu.com Key = taobao Value = http://www.taobao.com
Vérifier si une Map contient une clé spécifiée
Vous pouvez utiliser la méthodeMap.containspour vérifier si une clé spécifiée existe dans une Map. Exemple :
Exemple
def main(args: Array[String]) {
val sites = Map(\"example\" -> \"http://www.example.com\",
\"baidu\" -> \"http://www.baidu.com\",
\"taobao\" -> \"http://www.taobao.com\")
if( sites.contains( "example" )){
println("la clé example existe, la valeur correspondante est :" + sites("example"))
}else{
println("la clé example n'existe pas")
}
if( sites.contains( "baidu" )){
println("la clé baidu existe, la valeur correspondante est :" + sites("baidu"))
}else{
println("la clé baidu n'existe pas")
}
if( sites.contains( "google" )){
println("la clé google existe, la valeur correspondante est :" + sites("google"))
}else{
println("la clé google n'existe pas")
}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test example 键存在，对应的值为 :http://www.example.com baidu 键存在，对应的值为 :http://www.baidu.com google 键不存在
Méthodes de Map en Scala
Le tableau suivant répertorie les méthodes courantes de Map en Scala :
| Non. | Méthode et description |
|---|---|
| 1 |
def ++(xs: Map[(A, B)]): Map[A, B] Renvoie une nouvelle Map composée de la nouvelle Map xs |
| 2 |
def -(elem1: A, elem2: A, elems: A*): Map[A, B] Renvoie une nouvelle Map, en supprimant les clés elem1, elem2, ou d'autres elems. |
| 3 |
def --(xs: GTO[A]): Map[A, B] Renvoie une nouvelle Map, en supprimant les clés correspondantes dans l'objet xs. |
| 4 |
def get(key: A): Option[B] Renvoie la valeur pour la clé spécifiée |
| 5 |
def iterator: Iterator[(A, B)] Crée un nouvel itérateur et produit des paires clé/valeur |
| 6 |
addString(b: StringBuilder): StringBuilder Ajoute tous les éléments de la Map à un StringBuilder, avec un séparateur facultatif |
| 7 |
def addString(b: StringBuilder, sep: String): StringBuilder Ajoute tous les éléments de la Map à un StringBuilder, avec un séparateur facultatif |
| 8 |
def apply(key: A): B Renvoie la valeur pour la clé spécifiée, ou la méthode par défaut de la Map si elle n'existe pas |
| 9 |
def clear(): Unit Vide la Map |
| 10 |
def clone(): Map[A, B] Copie d'une Map vers une autre Map |
| 11 |
def contains(key: A): Boolean Renvoie true si la clé spécifiée existe dans la Map, sinon renvoie false. |
| 12 |
def copyToArray(xs: Array[(A, B)]): Unit Copie la collection dans un tableau |
| 13 |
def count(p: ((A, B)) => Boolean): Int Compte le nombre d'éléments de la collection qui satisfont la condition spécifiée |
| 14 |
def default(key: A): B Définit la valeur par défaut de la Map, renvoyée lorsque la clé n'existe pas. |
| 15 |
def drop(n: Int): Map[A, B] Renvoie une nouvelle collection après avoir supprimé les n premiers éléments |
| 16 |
def dropRight(n: Int): Map[A, B] Renvoie une nouvelle collection après avoir supprimé les n derniers éléments |
| 17 |
def dropWhile(p: ((A, B)) => Boolean): Map[A, B] Supprime des éléments de gauche à droite jusqu'à ce que la condition p soit fausse |
| 18 |
def empty: Map[A, B] Renvoie une Map vide du même type |
| 19 |
def equals(that: Any): Boolean Renvoie true si deux Maps sont égales (égalité des clés et des valeurs), sinon renvoie false |
| 20 |
def exists(p: ((A, B)) => Boolean): Boolean Détermine si un élément qui satisfait la condition spécifiée existe dans la collection |
| 21 |
def filter(p: ((A, B))=> Boolean): Map[A, B] Renvoie tous les éléments qui satisfont la condition spécifiée |
| 22 |
def filterKeys(p: (A) => Boolean): Map[A, B] Renvoie une Map immuable qui satisfait la condition spécifiée |
| 23 |
def find(p: ((A, B)) => Boolean): Option[(A, B)] Trouve le premier élément de la collection qui satisfait la condition spécifiée |
| 24 |
def foreach(f: ((A, B)) => Unit): Unit Applique une fonction à tous les éléments de la collection |
| 25 |
def init: Map[A, B] Renvoie tous les éléments sauf le dernier |
| 26 |
def isEmpty: Boolean Vérifie si la Map est vide |
| 27 |
def keys: Iterable[A] Renvoie toutes les clés |
| 28 |
def last: (A, B) Renvoie le dernier élément |
| 29 |
def max: (A, B) Trouve le plus grand élément |
| 30 |
def min: (A, B) Trouve le plus petit élément |
| 31 |
def mkString: String Affiche tous les éléments de la collection sous forme de chaîne |
| 32 |
def product: (A, B) Renvoie le produit des éléments numériques de la collection. |
| 33 |
def remove(key: A): Option[B] Supprime la clé spécifiée |
| 34 |
def retain(p: (A, B) => Boolean): Map.this.type Renvoie true si la condition est remplie |
| 35 |
def size: Int Renvoie le nombre d'éléments dans le Map |
| 36 |
def sum: (A, B) Renvoie la somme de tous les éléments numériques de la collection |
| 37 |
def tail: Map[A, B] Renvoie tous les éléments d'une collection sauf le premier élément |
| 38 |
def take(n: Int): Map[A, B] Renvoie les n premiers éléments |
| 39 |
def takeRight(n: Int): Map[A, B] Renvoie les n derniers éléments |
| 40 |
def takeWhile(p: ((A, B)) => Boolean): Map[A, B] Renvoie les éléments qui satisfont la condition spécifiée |
| 41 |
def toArray: Array[(A, B)] Convertit la collection en tableau |
| 42 |
def toBuffer[B >: A]: Buffer[B] Renvoie un tampon contenant tous les éléments de la Map |
| 43 |
def toList: List[A] Renvoie une List contenant tous les éléments de la Map |
| 44 |
def toSeq: Seq[A] Retourne une Seq contenant tous les éléments de la Map |
| 45 |
def toSet: Set[A] Retourne un Set contenant tous les éléments de la Map |
| 46 |
def toString(): String Retourne un objet chaîne de caractères |
Pour plus de méthodes, reportez-vous à ladocumentation de l'API
Autres extensions