Scala Mappa (mappa)
Mappa (mappa) è una sorta di coppie chiave-valore iterativi (chiave / valore) struttura.
Tutti i valori possono essere recuperati da una chiave.
Mappa la chiave è unica.
Mappa è anche chiamato una tabella di hash (tabelle hash).
Mappa Ci sono due tipi di variabili e non possono essere modificati, salvo che l'oggetto variabile può modificarlo senza oggetti mutabili non può.
Per impostazione predefinita, Scala immutabile mappa. Se è necessario utilizzare una collezione di variabili, è necessario introdurre esplicitamente classeimportazione scala.collection.mutable.Map
In Scala è possibile utilizzare variabile e immutabile mappa, uso diretto Mappa immutabile, mutabili uso mutable.Map. L'esempio seguente mostra l'applicazione di immutabile Mappa:
// 空哈希表,键为字符串,值为整型 var A:Map[Char,Int] = Map() // Map 键值对演示 val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF")
Quando si definisce una mappa, è necessario definire il tipo di coppie chiave-valore. Se è necessario aggiungere coppie chiave-valore, è possibile utilizzare il segno +, come segue:
A += ('I' -> 1) A += ('J' -> 5) A += ('K' -> 10) A += ('L' -> 100)
Operazioni di base Mappa
Scala Mappa Ci sono tre operazioni di base:
modo | descrizione |
---|---|
chiavi | Indietro Mappa tutte le chiavi (chiave) |
valori | Mappa restituisce tutti i valori (valore) |
isEmpty | Nella mappa è vero le corse a vuoto |
Esempi
Il seguente esempio illustra l'applicazione dei tre metodi di base di cui sopra:
object Test { def main(args: Array[String]) { val colors = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F") val nums: Map[Int, Int] = Map() println( "colors 中的键为 : " + colors.keys ) println( "colors 中的值为 : " + colors.values ) println( "检测 colors 是否为空 : " + colors.isEmpty ) println( "检测 nums 是否为空 : " + nums.isEmpty ) } }
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test colors 中的键为 : Set(red, azure, peru) colors 中的值为 : MapLike(#FF0000, #F0FFFF, #CD853F) 检测 colors 是否为空 : false 检测 nums 是否为空 : true
Mappa di fusione
È possibile utilizzare l'operatore++ o mappa. ++ ()Metodo per collegare due mappa, rimuove chiave duplicata quando Map fusione. I seguenti due esempi dimostrano l'combinato Mappa:
object Test { def main(args: Array[String]) { val colors1 = Map("red" -> "#FF0000", "azure" -> "#F0FFFF", "peru" -> "#CD853F") val colors2 = Map("blue" -> "#0033FF", "yellow" -> "#FFFF00", "red" -> "#FF0000") // ++ 作为运算符 var colors = colors1 ++ colors2 println( "colors1 ++ colors2 : " + colors ) // ++ 作为方法 colors = colors1.++(colors2) println( "colors1.++(colors2)) : " + colors ) } }
L'attuazione del codice di cui sopra, l'output è:
$ 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)
Mappa di chiavi e valori di uscita
Il seguente ciclo foreach attraverso l'uscita Mappa di chiavi e valori:
object Test { def main(args: Array[String]) { val sites = Map("w3big" -> "http://www.w3big.com", "baidu" -> "http://www.baidu.com", "taobao" -> "http://www.taobao.com") sites.keys.foreach{ i => print( "Key = " + i ) println(" Value = " + sites(i) )} } }
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test Key = w3big Value = http://www.w3big.com Key = baidu Value = http://www.baidu.com Key = taobao Value = http://www.taobao.com
Controllare se la chiave specificata esiste nella mappa
È possibile utilizzare il metodoMap.contains per vedere se la presenza del specificato Key Map.Esempi sono i seguenti:
object Test { def main(args: Array[String]) { val sites = Map("w3big" -> "http://www.w3big.com", "baidu" -> "http://www.baidu.com", "taobao" -> "http://www.taobao.com") if( sites.contains( "w3big" )){ println("w3big 键存在,对应的值为 :" + sites("w3big")) }else{ println("w3big 键不存在") } if( sites.contains( "baidu" )){ println("baidu 键存在,对应的值为 :" + sites("baidu")) }else{ println("baidu 键不存在") } if( sites.contains( "google" )){ println("google 键存在,对应的值为 :" + sites("google")) }else{ println("google 键不存在") } } }
L'attuazione del codice di cui sopra, l'output è:
$ scalac Test.scala $ scala Test w3big 键存在,对应的值为 :http://www.w3big.com baidu 键存在,对应的值为 :http://www.baidu.com google 键不存在
Metodo Scala Mappa
Nella tabella seguente sono elencati i metodi comunemente utilizzati Scala Mappa:
No. | Metodo e Descrizione |
---|---|
1 | DEF ++ (xs: Mappa [( A, B)]): Mappa [A, B] Si restituisce una nuova mappa, Nuova mappa xs composizione |
2 | DEF - (elem1: A, elem2 : A, elems: A *): Mappa [A, B] Restituisce una nuova mappa, rimuovere la chiave per elem1, elem2 o altro elems. |
3 | DEF - (xs: GTO [A ]): Mappa [A, B] Restituisce una nuova mappa, rimuovere xs oggetto tasto corrispondente |
4 | def ottenere (tasto A): Opzione [B] Restituisce il valore della chiave specificata |
5 | DEF iteratore: Iterator [(A, B)] Creare un nuovo iteratore, ed emette la coppia chiave / valore |
6 | def AddString (B: StringBuilder): StringBuilder La mappa tutti gli elementi collegati al StringBuilder, possono essere aggiunti a un separatore |
7 | def AddString (B: StringBuilder, settembre : String): StringBuilder La mappa tutti gli elementi collegati al StringBuilder, possono essere aggiunti a un separatore |
8 | applicare DEF (tasto: A): B Restituisce il valore della chiave specificata, se non vi è ritorno al metodo predefinito Mappa |
9 | DEF chiaro (): Unità Cancella mappa |
10 | DEF clone (): Mappa [A , B] Da uno all'altro Mappa |
11 | DEF contiene (tasto A): booleano Se c'è una chiave Mappa specificato, restituisce vero, altrimenti restituisce false. |
12 | def copyToArray (xs: Array [( A, B)]): Unità Copia impostato su una matrice |
13 | def contare (p: ((A , B)) => booleana): Int Calcolare il numero di elementi che soddisfano i criteri specificati stabiliti |
14 | def di default (tasto: A): B Il valore di default è definito Mappa ritorna quando la chiave non è presente. |
15 | def cadere (n: Int): Mappa [A, B] La nuova collezione prima di scarti di ritorno n elementi |
16 | def dropRight (n: Int): Mappa [A, B] Torna scartare gli ultimi n elementi della nuova collezione |
17 | def dropWhile (p: ((A , B)) => booleana): Mappa [A, B] elemento di scarto da sinistra a destra, fino a quando la condizione non è soddisfatta p |
18 | DEF vuoto: Mappa [A, B ] Restituisce lo stesso tipo di vuoto Mappa |
19 | DEF è uguale (che: Qualsiasi): booleano Se i due sono uguali Mappa (chiave / valore sono uguali), restituisce true, altrimenti false |
20 | esiste DEF (p: ((A , B)) => booleana): booleano Analizzando le condizioni di cui l'elemento di raccolta esiste |
21 | def filtrare (p: ((A , B)) => booleana): Mappa [A, B] Torna a tutte le collezioni che soddisfano i criteri specificati |
22 | def Filtro (p: (A) => booleana): Mappa [A, B] Restituisce immutabile Mappa soddisfano i criteri specificati di |
23 | def trovare (p: ((A , B)) => booleana): Opzione [(A, B)] Trovare il primo elemento della collezione che soddisfa i criteri specificati |
24 | def foreach (f: ((A , B)) => Unità): Unità Tutti gli elementi della funzione al set |
25 | def init: Mappa [A, B ] Restituisce tutti gli elementi, tranne l'ultimo |
26 | DEF isEmpty: booleano Rilevare se la mappa è vuota |
27 | Tasti Def: Iterable [A] Restituire tutto chiave / p> |
28 | DEF ultima: (A, B) Restituisce l'ultimo elemento |
29 | def max: (A, B) Trova l'elemento massimo |
30 | Def Min: (A, B) Trova l'elemento più piccolo |
31 | DEF mkString: String L'insieme di tutti gli elementi del display sotto forma di stringa |
32 | prodotto DEF: (A, B) Restituisce un insieme di elementi digitali nella trama. |
33 | def rimuovere (tasto A): Opzione [B] Rimuove la chiave specificata |
34 | def mantenere (p: (A, B) => booleana): Map.this.type Se soddisfano la condizione restituisce true |
35 | dimensione DEF: Int Restituisce il numero di elementi in Mappa |
36 | def somma: (A, B) Restituisce un insieme di tutti gli elementi del digitale |
37 | DEF coda: Mappa [A, B ] Restituisce un insieme di altri elementi tranne il primo elemento |
38 | def prendere (n: Int): Mappa [A, B] Restituisce i primi n elementi |
39 | def takeRight (n: Int): Mappa [A, B] n elementi Indietro |
40 | def TakeWhile (p: ((A , B)) => booleana): Mappa [A, B] Restituisce elementi condizione specificata è soddisfatta |
41 | DEF toArray: Array [(A, B)] Set serie di trasferimento |
42 | DEF toBuffer [B>: A] : Buffer [B] buffer posteriore, contenente tutti gli elementi della mappa |
43 | DEF listaA: Lista [A] Elenco indietro, contiene tutti gli elementi della mappa |
44 | DEF toSeq: Seq [A] Indietro Seq, contiene tutti gli elementi Mappa |
45 | DEF Toset: Impostare [A] Indietro Imposta, che contiene tutti gli elementi della mappa |
46 | def toString (): String Restituisce un oggetto String |
Altri modi per fare riferimento alla documentazione delle API