建立Map

// 建立一個不可變的Map
val ages = Map("Leo" -> 30, "Jen" -> 25, "Jack" -> 23)
ages("Leo") = 31
// 建立一個可變的Map
val ages = scala.collection.mutable.Map("Leo" -> 30, "Jen" -> 25, "Jack" -> 23)
ages("Leo") = 31
// 使用另外一種方式定義Map元素
val ages = Map(("Leo", 30), ("Jen", 25), ("Jack", 23))
// 建立一個空的HashMap
val ages = new scala.collection.mutable.HashMap[String, Int]
 

訪問Map的元素

// 獲取指定key對應的value，如果key不存在，會報錯
val leoAge = ages("Leo")
val leoAge = ages("leo")

// 使用contains函式檢查key是否存在
val leoAge = if (ages.contains("leo")) ages("leo") else 0

// getOrElse函式
val leoAge = ages.getOrElse("leo", 0)

修改Map的元素

// 更新Map的元素
ages("Leo") = 31
// 增加多個元素
ages += ("Mike" -> 35, "Tom" -> 40)
// 移除元素
ages -= "Mike"
// 更新不可變的map
val ages2 = ages + ("Mike" -> 36, "Tom" -> 40)
// 移除不可變map的元素
val ages3 = ages - "Tom"
 

遍歷Map

// 遍歷map的entrySet
for ((key, value) <- ages) println(key + " " + value)
// 遍歷map的key
for (key <- ages.keySet) println(key)
// 遍歷map的value
for (value <- ages.values) println(value)
// 生成新map，反轉key和value
for ((key, value) <- ages) yield (value, key)

SortedMap和LinkedHashMap

// SortedMap可以自動對Map的key的排序
val ages = scala.collection.immutable.SortedMap("leo" -> 30, "alice" -> 15, "jen" -> 25)

// LinkedHashMap可以記住插入entry的順序
val ages = new scala.collection.mutable.LinkedHashMap[String, Int]
ages("leo") = 30
ages("alice") = 15
ages("jen") = 25
 

Map的元素型別—Tuple

與列表一樣，元組也是不可變的，但與列表不同的是元組可以包含不同型別的元素。
元組的值是通過將單個的值包含在圓括號中構成的。例如：

// 簡單Tuple
val t = ("leo", 30)

// 訪問Tuple
t._1

// zip操作
val names = Array("leo", "jack", "mike")
val ages = Array(30, 24, 26)
val nameAges = names.zip(ages)
for ((name, age) <- nameAges) println(name + ": " + age)

val t = (1, 3.14, "Fred")  
object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)

      val sum = t._1 + t._2 + t._3 + t._4

      println( "元素之和為: "  + sum )
   }
}

迭代元組

你可以使用 Tuple.productIterator() 方法來迭代輸出元組的所有元素：

object Test {
   def main(args: Array[String]) {
      val t = (4,3,2,1)
      
      t.productIterator.foreach{ i =>println("Value = " + i )}
   }
}

元組轉為字串

你可以使用 Tuple.toString() 方法將元組的所有元素組合成一個字串，例項如下：

object Test {
   def main(args: Array[String]) {
      val t = new Tuple3(1, "hello", Console)
      
      println("連線後的字串為: " + t.toString() )
   }
}

元素交換

你可以使用 Tuple.swap 方法來交換元組的元素。如下例項：

object Test {
   def main(args: Array[String]) {
      val t = new Tuple2("www.google.com", "www.runoob.com")
      
      println("交換後的元組: " + t.swap )
   }
}

小案例（統計多個文字檔案的單詞總數）

object Tongji {
  def main(args: Array[String]): Unit = {
    //使用scala的IO包將文字檔案的資料讀取出來
    val line1=scala.io.Source.fromFile("C://Users//zy//Desktop//jinmi.txt").mkString//檔案路徑

    val line2=scala.io.Source.fromFile("C://Users//zy//Desktop//jin.txt").mkString
    //使用List的伴生物件，將多個檔案內的內容建立一個List
    val lines =List(line1,line2)
    //讀取出來應該是一個List比如List("gfhdf gh yut dgfh","et6 fegf fds dfsa")

    lines.flatMap(_.split(" ")).map((_,1)).map(_._2).reduceLeft(_+_)
    //將List按照空格切割就會形成一個新的list比如：list(gfhd hfkj asdh hdgk sdbhk 766 hfk)
    //.map((_,1))意思就是形成一個個Tuple格式比如（sghd,1）(gdfhj,1)
    //.map(_._2)意思就是將前面的Tuple中後面的元素提取出來比如形成(1)(1)(1)
    //reduceLeft(_+_)意思就是從左邊加起，第一個1加上第二個1之後再與第三個相加依次類推
  }
}

//Tuple拉鍊操作指的是zip操作

//zip操作，是Array類的方法，用於將兩個Array合併為一個Array
// 比如Array(v1)和Array(v2),使用zip操作合併後的格式為Array(v1,v2)
//合併後的Array的元素型別為Tuple
val students =Array("leo","jack","jen")
val scores=Array(80,100,90)
val studentScores= students.zip(scores)
for ((student,score) <- studentScores)
  println(student+"\t"+score)
//如果Array的元素型別是個Tuple，呼叫Array的toMap方法，可以將Array轉換為Map
studentScores.toMap


//Java Map 與Scala Map的隱式轉換
  //java to scala
  import scala.collection.JavaConversions.mapAsScalaMap
  val javaScores =new util.HashMap[String,Int]()
  javaScores.put("Alice",10)
  javaScores.put("Bob",3)
  javaScores.put("Cindy",8)
  val scalaScores:scala.collection.mutable.Map[String,Int]=javaScores
  //scala to java
  import scala.collection.JavaConversions.mapAsJavaMap
  import java.awt.font.TextAttribute._
  val scalaAttrMap =Map(FAMILY -> "Serif",SIZE ->12)
  val fONT =new Font(scalaAttrMap)