Scala Map
Scala CollectionsEine Map ist eine iterierbare Schlüssel/Wert-Struktur.
Alle Werte können über Schlüssel abgerufen werden.
Schlüssel in einer Map sind eindeutig.
Eine Map wird auch als Hash-Tabelle bezeichnet.
Map hat zwei Typen: veränderlich und unveränderlich. Der Unterschied besteht darin, dass veränderliche Objekte geändert werden können, während unveränderliche Objekte nicht.
Standardmäßig verwendet Scala unveränderliche Map. Wenn Sie eine veränderliche Collection verwenden müssen, müssen Sie explizit die Klasseimport scala.collection.mutable.Mapimportieren.
In Scala können Sie sowohl veränderliche als auch unveränderliche Maps verwenden. Für unveränderliche verwenden Sie Map direkt; für veränderliche verwenden Sie mutable.Map. Das folgende Beispiel demonstriert die Anwendung einer unveränderlichen Map:
// 空哈希表，键为字符串，值为整型
var A:Map[Char,Int] = Map()
// Map 键值对演示
val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
Beim Definieren einer Map müssen Sie Typen für Schlüssel-Wert-Paare definieren. Wenn Sie Schlüssel-Wert-Paare hinzufügen möchten, können Sie das +-Zeichen verwenden, wie unten gezeigt:
A += ('I' -> 1)
A += ('J' -> 5)
A += ('K' -> 10)
A += ('L' -> 100)
Grundlegende Map-Operationen
Scala Map hat drei grundlegende Operationen:
| Methode | Beschreibung |
|---|---|
| keys | Gibt alle Schlüssel der Map zurück |
| values | Gibt alle Werte der Map zurück |
| isEmpty | Gibt true zurück, wenn die Map leer ist |
Beispiel
Das folgende Beispiel demonstriert die grundlegende Anwendung der oben genannten drei Methoden:
Beispiel
def main(args: Array[String]) {
val colors = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val nums: Map[Int, Int] = Map()
println( "Die Schlüssel in colors sind: " + colors.keys )
println( "Die Werte in colors sind: " + colors.values )
println( "Prüfen, ob colors leer ist: " + colors.isEmpty )
println( "Prüfen, ob nums leer ist: " + nums.isEmpty )
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test colors 中的键为 : Set(red, azure, peru) colors 中的值为 : MapLike(#FF0000, #F0FFFF, #CD853F) 检测 colors 是否为空 : false 检测 nums 是否为空 : true
Map-Zusammenführung
Sie können den++Operator oder dieMap.++()-Methode verwenden, um zwei Maps zu verketten. Wenn Maps zusammengeführt werden, werden doppelte Schlüssel entfernt. Das Folgende zeigt ein Beispiel für das Zusammenführen von zwei Maps:
Beispiel
def main(args: Array[String]) {
val colors1 = Map("red" -> "#FF0000",
"azure" -> "#F0FFFF",
"peru" -> "#CD853F")
val colors2 = Map("blue" -> "#0033FF",
"yellow" -> "#FFFF00",
"red" -> "#FF0000")
// ++ als Operator
var colors = colors1 ++ colors2
println( "colors1 ++ colors2 : " + colors )
// ++ als Methode
colors = colors1.++(colors2)
println( "colors1.++(colors2) : " + colors )
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ 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)
Ausgabe der Schlüssel und Werte einer Map
Das Folgende verwendet eine foreach-Schleife, um die Schlüssel und Werte in einer Map auszugeben:
Beispiel
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( "Schlüssel = " + i )
println(" Wert = " + sites(i) )}
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ 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
Prüfen, ob eine Map einen angegebenen Schlüssel enthält
Sie können die MethodeMap.containsverwenden, um zu prüfen, ob ein angegebener Schlüssel in einer Map existiert. Beispiel:
Beispiel
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("Der Schlüssel example existiert, der zugehörige Wert ist:" + sites("example"))
}else{
println("Der Schlüssel example existiert nicht")
}
if( sites.contains( "baidu" )){
println("Der Schlüssel baidu existiert, der zugehörige Wert ist:" + sites("baidu"))
}else{
println("Der Schlüssel baidu existiert nicht")
}
if( sites.contains( "google" )){
println("Der Schlüssel google existiert, der zugehörige Wert ist:" + sites("google"))
}else{
println("Der Schlüssel google existiert nicht")
}
}
}
Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:
$ scalac Test.scala $ scala Test example 键存在，对应的值为 :http://www.example.com baidu 键存在，对应的值为 :http://www.baidu.com google 键不存在
Scala Map Methoden
Die folgende Tabelle listet gängige Methoden von Scala Map auf:
| Nein. | Methode und Beschreibung |
|---|---|
| 1 |
def ++(xs: Map[(A, B)]): Map[A, B] Gibt eine neue Map zurück, die aus der neuen Map xs besteht |
| 2 |
def -(elem1: A, elem2: A, elems: A*): Map[A, B] Gibt eine neue Map zurück, wobei die Schlüssel elem1, elem2 oder andere elems entfernt werden. |
| 3 |
def --(xs: GTO[A]): Map[A, B] Gibt eine neue Map zurück, wobei die entsprechenden Schlüssel im xs-Objekt entfernt werden. |
| 4 |
def get(key: A): Option[B] Gibt den Wert für den angegebenen Schlüssel zurück |
| 5 |
def iterator: Iterator[(A, B)] Erstellt einen neuen Iterator und gibt Schlüssel/Wert-Paare aus |
| 6 |
def addString(b: StringBuilder): StringBuilder Hängt alle Elemente der Map an einen StringBuilder an, mit einem optionalen Trennzeichen |
| 7 |
def addString(b: StringBuilder, sep: String): StringBuilder Hängt alle Elemente der Map an einen StringBuilder an, mit einem optionalen Trennzeichen |
| 8 |
def apply(key: A): B Gibt den Wert für den angegebenen Schlüssel zurück oder die default-Methode der Map, wenn er nicht existiert |
| 9 |
def clear(): Unit Leert die Map |
| 10 |
def clone(): Map[A, B] Kopiert von einer Map in eine andere Map |
| 11 |
def contains(key: A): Boolean Gibt true zurück, wenn der angegebene Schlüssel in der Map existiert, andernfalls false. |
| 12 |
def copyToArray(xs: Array[(A, B)]): Unit Kopiert die Collection in ein Array |
| 13 |
def count(p: ((A, B)) => Boolean): Int Zählt die Anzahl der Collection-Elemente, die die angegebene Bedingung erfüllen |
| 14 |
def default(key: A): B Definiert den Standardwert der Map, der zurückgegeben wird, wenn der Schlüssel nicht existiert. |
| 15 |
def drop(n: Int): Map[A, B] Gibt eine neue Sammlung zurück, nachdem die ersten n Elemente verworfen wurden |
| 16 |
def dropRight(n: Int): Map[A, B] Gibt eine neue Sammlung zurück, nachdem die letzten n Elemente verworfen wurden |
| 17 |
def dropWhile(p: ((A, B)) => Boolean): Map[A, B] Verwirft Elemente von links nach rechts, bis die Bedingung p falsch ist |
| 18 |
def empty: Map[A, B] Gibt eine leere Map desselben Typs zurück |
| 19 |
def equals(that: Any): Boolean Gibt true zurück, wenn zwei Maps gleich sind (sowohl Schlüssel als auch Wert gleich), andernfalls false |
| 20 |
def exists(p: ((A, B)) => Boolean): Boolean Bestimmt, ob ein Element, das die angegebene Bedingung erfüllt, in der Sammlung vorhanden ist |
| 21 |
def filter(p: ((A, B))=> Boolean): Map[A, B] Gibt alle Elemente zurück, die die angegebene Bedingung erfüllen |
| 22 |
def filterKeys(p: (A) => Boolean): Map[A, B] Gibt eine unveränderliche Map zurück, die die angegebene Bedingung erfüllt |
| 23 |
def find(p: ((A, B)) => Boolean): Option[(A, B)] Findet das erste Element in der Collection, das die angegebene Bedingung erfüllt |
| 24 |
def foreach(f: ((A, B)) => Unit): Unit Wendet eine Funktion auf alle Elemente der Collection an |
| 25 |
def init: Map[A, B] Gibt alle Elemente außer dem letzten zurück |
| 26 |
def isEmpty: Boolean Prüft, ob die Map leer ist |
| 27 |
def keys: Iterable[A] Gibt alle Schlüssel zurück |
| 28 |
def last: (A, B) Gibt das letzte Element zurück |
| 29 |
def max: (A, B) Findet das größte Element |
| 30 |
def min: (A, B) Findet das kleinste Element |
| 31 |
def mkString: String Zeigt alle Elemente der Sammlung als Zeichenkette an |
| 32 |
def product: (A, B) Gibt das Produkt der numerischen Elemente in der Sammlung zurück. |
| 33 |
def remove(key: A): Option[B] Entfernt den angegebenen Schlüssel |
| 34 |
def retain(p: (A, B) => Boolean): Map.this.type Gibt true zurück, wenn die Bedingung erfüllt ist |
| 35 |
def size: Int Gibt die Anzahl der Elemente in der Map zurück |
| 36 |
def sum: (A, B) Gibt die Summe aller numerischen Elemente in der Sammlung zurück |
| 37 |
def tail: Map[A, B] Gibt alle Elemente einer Sammlung außer dem ersten Element zurück |
| 38 |
def take(n: Int): Map[A, B] Gibt die ersten n Elemente zurück |
| 39 |
def takeRight(n: Int): Map[A, B] Gibt die letzten n Elemente zurück |
| 40 |
def takeWhile(p: ((A, B)) => Boolean): Map[A, B] Gibt Elemente zurück, die die angegebene Bedingung erfüllen |
| 41 |
def toArray: Array[(A, B)] Konvertiert eine Sammlung in ein Array |
| 42 |
def toBuffer[B >: A]: Buffer[B] Gibt einen Puffer zurück, der alle Elemente der Map enthält |
| 43 |
def toList: List[A] Gibt eine List zurück, die alle Elemente der Map enthält |
| 44 |
def toSeq: Seq[A] Gibt eine Seq zurück, die alle Elemente der Map enthält |
| 45 |
def toSet: Set[A] Gibt ein Set zurück, das alle Elemente der Map enthält |
| 46 |
def toString(): String Gibt ein String-Objekt zurück |
Weitere Methoden finden Sie in derAPI-Dokumentation
Weitere Erweiterungen