Scala中的Map集合

1. Map集合

1.1 Scala中的Map介紹

Scala中的Map 和Java類似，也是一個散列表，它存儲的內容也是鍵值對(key-value)映射，Scala中不可變的Map是有序的，可變的Map是無序的。

Scala中，有可變Map (scala.collection.mutable.Map) 和 不可變Map(scala.collection.immutable.Map)

1.2 構建map

1. 構建不可變map

​ Scala中的不可變Map是有序，構建Map中的元素底層是Tuple2類型。

val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")

• 不可變map，輸出順序和聲明順序一致
• 構建Map集合中，集合中的元素其實是Tuple2類型
• 默認情況下（即沒有引入其它包的情況下）,Map是不可變map

2. 構建可變map //需要指定可變Map的包

val map2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> 30)

​ 說明：可變map輸出順序和聲明順序不一致

3. 構建空map

val map3 = new scala.collection.mutable.HashMap[String, Int]

4. 使用對偶元組，構建map

​ 即創建包含鍵值對的二元組， 和第一種方式等價，只是形式上不同而已。對偶元組 就是只含有兩個數據的元組。

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30) )

1.3 Map操作

1. 添加map元素

​ 方式1-增加單個元素

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4 += ( "D" -> 4 )
map4 += ( "B" -> 50 )
println(map4)

​ 思考：如果增加的key 已經存在會怎么樣？

​ 如果在添加元素的時候，對應的key已經存在，則會更新key所對應的value值。

2. 方式2-增加多個元素

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
val map5 = map4 + ("E"->1, "F"->3)
map4 += ("EE"->1, "FF"->3)  

3. 刪除map元素

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4 -= ("A", "B")
println("map4=" + map4)

說明

• "A","B" 就是要刪除的key, 可以寫多個.
• 如果key存在，就刪除，如果key不存在，也不會報錯.

1.4 Map取值

1. 方式1-使用map(key)

val value1 = map2("Alice") 
println(value1)

說明:

• 如果key存在，則返回對應的值
• 如果key不存在，則拋出異常[java.util.NoSuchElementException]
• 在Java中,如果key不存在則返回null

2. 方式2-使用contains方法檢查是否存在key

​ // 返回Boolean
​ // 1.如果key存在，則返回true
​ // 2.如果key不存在，則返回false
​ map4.contains("B")

​ 說明:使用containts先判斷在取值，可以防止異常，並加入相應的處理邏輯

val map4 = mutable.Map( ("A", 1), ("B", 2), ("C", 3),("D", 30.9) )
if( map4.contains("B") ) {
println("key存在值= " + map4("B"))
} else {
println("key不存在")
}

3. 方式3-使用map.get(key).get取值
   通過調用“.get”方法，返回一個Option對象，要么是Some，要么是None

var map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.get("A")) //Some
println(map4.get("A").get) //得到Some在取出

說明和小結:

• map.get方法會將數據進行包裝
• 如果 map.get(key) key存在返回some,如果key不存在，則返回None
• 如果 map.get(key).get key存在，返回key對應的值,否則，拋出異常java.util.NoSuchElementException: None.get

4. 方式4-使用map4.getOrElse()取值

getOrElse 方法 : def getOrElse[V1 >: V](key: K, default: => V1)

說明：

• 如果key存在，返回key對應的值。
• 如果key不存在，返回默認值。在java中底層有很多類似的操作。

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
println(map4.getOrElse("A","默認"))

5. 取值方式選擇建議
   • 若能確定map有key ,使用map(key), 速度快
   • 若不能確定map是否有key ,而且有不同的業務邏輯，使用map.contains() ，先判斷再加入邏輯
   • 若只是得到一個值，使用map4.getOrElse("ip","127.0.0.1")

1.5 更新Map

val map4 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
map4("AA") = 20
println(map4)

• map 是可變的，才能修改，否則報錯
• 如果key存在：則修改對應的值,key不存在,等價於添加一個key-value

1.6 Map遍歷

val map1 = mutable.Map( ("A", 1), ("B", "北京"), ("C", 3) )
for ((k, v) <- map1) println(k + " is mapped to " + v)//模式匹配的方式
for (v <- map1.keys) println(v)//打印Key
for (v <- map1.values) println(v)//打印value
for(v <- map1) println(v) //v是Tuple

說明
1.每遍歷一次，返回的元素是Tuple2
2.取出的時候，可以按照元組的方式來取

1.7 綜合應用實例

object MapDemo01 {
  def main(args: Array[String]): Unit = {

    //方式1-構造不可變映射
    //1.默認Map是 immutable.Map
    //2.key-value 類型支持Any
    //3.在Map的底層，每對key-value是Tuple2
    //4.從輸出的結果看到，輸出順序和聲明順序一致
    val map1 = Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
    println(map1)


    //方式2-構造可變映射
    //1.從輸出的結果看到，可變的map輸出順序和聲明順序不一致
    val map2 = mutable.Map("Alice" -> 10, "Bob" -> 20, "Kotlin" -> "北京")
    println(map2)

    //方式3-創建空的映射

    val map3 = new scala.collection.mutable.HashMap[String, Int]
    println("map3=" + map3)

    //方式4-對偶元組
    val map4 = mutable.Map(("Alice", 10), ("Bob", 20), ("Kotlin", "北京"))
    println("map4=" + map4)

    map4 += ( "D" -> 4 )
    map4 += ( "B" -> 50 )

    println("map4=" +map4)

    //方式1-使用map(key)
    println(map4("Alice")) // 10
    //拋出異常（java.util.NoSuchElementException: key not found:）
    //println(map4("Alice~"))

    //方式2-使用contains方法檢查是否存在key
    if (map4.contains("Alice")) {
      println("key存在，值=" + map4("Alice"))
    } else {
      println("key不存在:)")
    }

    //方式3 方式3-使用map.get(key).get取值
    //1. 如果key存在 map.get(key) 就會返回Some(值)  ,然后Some(值).get就可以取出
    //2. 如果key不存在 map.get(key) 就會返回None

    println(map4.get("Alice").get)
    //println(map4.get("Alice~").get)  // 拋出異常

    //方式4-使用map4.getOrElse()取值
    println(map4.getOrElse("Alice~~~", "默認的值 魚 <・)))><<"))


    val map5 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    map5("A") = 20 //增加
    println("map5=" + map5)

    map5 += ("A" -> 100)
    println("map5=" + map5)


    val mapVar = map5 + ("E"->1, "F"->3)
    println("mapVar=" + mapVar)
    map5 += ("GG"->1, "HH"->3)
    println("map5=" + map5)


    map5 -= ("A", "B", "AAA") //
    println("map5=" + map5)

    //map的遍歷
    val map6 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    println("----(k, v) <- map6--------")
    for ((k, v) <- map6) println(k + " is mapped to " + v)

    println("----v <- map6.keys--------")
    for (v <- map6.keys) println(v)
    println("----v <- map6.values--------")
    for (v <- map6.values) println(v)

    //這樣取出方式 v 類型是 Tuple2
    println("----v <- map6--------")
    for (v <- map6) println(v + " key =" + v._1 + " val=" + v._2) //v是Tuple?

    val map7 = mutable.Map(("Alice", 10), ("Bob", 20), ("Kotlin", "北京"))
    val map8 = mutable.Map(("A", 1), ("B", "北京"), ("C", 3))
    map7 ++= map8
    println("map7=" + map7) //map7=Map(Bob -> 20, A -> 1, Kotlin -> 北京, C -> 3, Alice -> 10, B -> 北京)
    val map9=map7 ++ map8
    println("map9=" + map9) //map9=Map(Bob -> 20, Kotlin -> 北京, A -> 1, C -> 3, Alice -> 10, B -> 北京)
    
  }
}