快學Scala-第四章 映射和元組

知識點：

1.構造映射，映射是對偶的集合

val scores1 = Map("Alice" -> 10, "Bob" -> 7, "Cindy" -> 9) //不可變映射
// val scores1 = Map(("Alice",),("Bob",),("Cindy",))
val scores2 = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 7, "Cindy" -> 9) //可變映射
//構造一個空的映射
val scores3 = new scala.collection.mutable.HashMap[String,Int]

2.獲取映射中的值

val bobscore = scores1("Bob") //若是不包含，則拋出異常
val bobscore1 = if(scores1.contains("Bob")) scores1("Bob") else 0
val bobscore2 = scores1.getOrElse("Bob", 0)

3.更新映射、迭代映射

在可變映射中，能夠更新某個映射的值，或者添加一個新的映射關係，作法是在=號的左側使用（）

//可變映射
scores2("Bob") = 9
scores2("Fred") = 8
scores2 += ("Bob" -> 9, "Fred" -> 8)
scores2 -= "Alice"
     
//不可變映射 
val newscores = scores1 + ("Bob" -> 9, "Fred" -> 8) //更新過的新映射，將結果做爲新值保存
//更新var變量
var varscores =  Map("Alice" -> 10, "Bob" -> 7, "Cindy" -> 9)
varscores = varscores + ("Bob" -> 9, "Fred" -> 8)
varscores = varscores - "Alice"
     
//迭代映射
for((k,v) <- scores1) //處理k,v
scores1.keySet        //得到相似於 Set("a","b","c")這樣的集合
for(v <- scores1.values) println(v) //values方法返回一個Iterable，能夠在for循環中使用
for((k,v) <- scores1) yield (v,k) //反轉一個映射

4.已排序映射

以下獲得不可變的樹型映射：

val scores4 = scala.collection.immutable.SortedMap("Alice" -> 10, "Bob" -> 7, "Cindy" -> 9)

對於可變的樹型映射，最接近的選擇是使用Java的TreeMap。

若是按插入順序訪問全部鍵，則使用LinkedHashMap。

val months = scala.collection.mutable.LinkedHashMap("January" -> 1,"February" -> 2,"March" -> 3,"April" -> 4, "May" -> 5,...)

5.與Java的互操做

將Java映射轉換成一個Scala映射，以便使用更便捷的Scala映射API，這對於須要操做Scala並未提供的可變樹形映射頗有用。

import scala.collection.JavaConversions.mapAsScalaMap
//指定Scala映射類型
val scores : scala.collection.mutable.Map[String,Int] = new java.util.TreeMap[String,Int]
     
//java.util.Properties->Map[String,String]
import scala.collection.JavaConversions.propertiesAsScalaMap
val props : scala.collection.Map[String,String] = System.getProperties()
     
//scala映射傳遞給預期的Java映射方法
import scala.collection.JavaConversions.mapAsJavaMap
import java.awt.font.TextAttribute._ //引入下面的映射會用到的鍵
val attrs = Map(FAMILY -> "Serif", SIZE -> 12) //scala映射
val font = new java.awt.Font(attrs) //該方法預期一個Java映射

6.元組

映射是鍵/值對偶的集合，對偶是元組的最簡單形態——元組是不一樣類型的值的彙集

元組的值是經過將單個的值包含在圓括號中構成的。使用_1 、_2 、_3訪問其組元，元組的各組元從1開始。

val = （1,3.14,」Fred」）

val second = t._2 //second設爲3.14

亦可 val second = t _2

7.拉鍊操做

val symbols = Array("<","-",">")
val counts = Array(2,10,2)
val pairs = symbols.zip(counts)
pairs.toMap   //拉鍊操做組合成一個映射

---

練習：（參考答案原網址）

1.設置一個映射,其中包含你想要的一些裝備，以及它們的價格。而後構建另外一個映射，採用同一組鍵，可是價格上打9折

scala> val price = Map("ipad" -> 4000,"iPhone" -> 6000, "iWatch" -> 3000)
price: scala.collection.immutable.Map[String,Int] = Map(ipad -> 4000, iPhone ->
6000, iWatch -> 3000)

scala> val newprice = for((k,v) <- price) yield (k, v * 0.9)
newprice: scala.collection.immutable.Map[String,Double] = Map(ipad -> 3600.0, iP
hone -> 5400.0, iWatch -> 2700.0)

2.編寫一段程序，從文件中讀取單詞。用一個可變映射來清點每一個單詞出現的頻率。讀取這些單詞的操做可使用java.util.Scanner: 
val in = new java.util.Scanner(new java.io.File("myfile.txt")) while(in.hasNext()) 處理 in.next() 或者翻到第9章看看更Scala的作法。 最後，打印出全部單詞和它們出現的次數。

import scala.io.Source
import scala.collection.mutable.HashMap

object Pract {
   def main(args: Array[String])  = {
      val source = Source.fromFile("file.txt").mkString
      val tokens = source.split("\\s+")
      val map = new HashMap[String,Int]
      
      for(key <- tokens){
        map(key) = map.getOrElse(key, 0) + 1
      }
      println(map.mkString(","))      
   }
}

3.重複前一個練習，此次用不可變的映射

不可變映射與可變映射的區別就是每次添加新的元素時都會返回一個新的映射。

import scala.io.Source

object Pract {
   def main(args: Array[String])  = {
      val source = Source.fromFile("file.txt").mkString
      val tokens = source.split("\\s+")
      var map = Map[String,Int]() //注意這裏用的 var 了
      
      for(key <- tokens){
          map += (key -> (map.getOrElse(key, 0) + 1))
      }
      println(map.mkString(","))      
   }
}

4.重複前一個練習，此次使用已排序的映射，以便單詞能夠按順序打印出來

import scala.io.Source
import scala.collection.SortedMap

object Pract {
   def main(args: Array[String])  = {
      val source = Source.fromFile("file.txt").mkString
      val tokens = source.split("\\s+")
      var sortedmap = SortedMap[String,Int]() //注意這裏用的 var 了
      
      for(key <- tokens){
          sortedmap += (key -> (sortedmap.getOrElse(key, 0) + 1))
      }
      println(sortedmap.mkString(","))      
   }
}

5.重複前一個練習，此次使用java.util.TreeMap並使之適用於Scala API

import scala.io.Source
import scala.collection.mutable.Map
import scala.collection.JavaConversions.mapAsScalaMap
import java.util.TreeMap

object Pract {
   def main(args: Array[String])  = {
      val source = Source.fromFile("file.txt").mkString
      val tokens = source.split("\\s+")
      val map:Map[String,Int] = new TreeMap[String,Int]
      
      for(key <- tokens){
         map(key) = map.getOrElse(key, 0) + 1
      }
      println(map.mkString(","))   
   }
}

6.定義一個鏈式哈希映射,將"Monday"映射到java.util.Calendar.MONDAY,依次類推加入其餘日期。展現元素是以插入的順序被訪問的

import scala.collection.mutable.LinkedHashMap
import java.util.Calendar

object Pract {
   def main(args: Array[String])  = {
      val map = new LinkedHashMap[String, Int]
      map += ("MONDAY" -> Calendar.MONDAY)
      map += ("TUESDAY" -> Calendar.TUESDAY)
      map += ("WENDSDAY" -> Calendar.WEDNESDAY)
      map += ("THURSDAY" -> Calendar.THURSDAY)
      map += ("FRIDAY" -> Calendar.FRIDAY)
      map += ("SATURDAY" -> Calendar.SATURDAY)
      map += ("SUNDAY" -> Calendar.SUNDAY)
      println(map.mkString(","))   
   }
}

7.打印出全部Java系統屬性的表格

JAVA系統屬性轉scala map的使用

import scala.collection.JavaConversions.propertiesAsScalaMap
import scala.collection.Map

object Pract {
   def main(args: Array[String])  = {
      val props: Map[String,String] = System.getProperties
      val keys = props.keySet
      val keylength = for( key <- keys) yield key.length
      val maxlength = keylength.max
      for( key <- keys) {
        print(key)
        print(" " * (maxlength - key.length))
        print("| ")
        println(props(key))
      }

   }
}

8.編寫一個函數minmax(values:Array[Int]),返回數組中最小值和最大值的對偶

def minmax(values:Array[Int])  = {
     (values.max,values.min)
   }

9.編寫一個函數Iteqgt(values:Array[int],v:Int),返回數組中小於v,等於v和大於v的數量，要求三個值一塊兒返回

def Iteqgt(values:Array[Int],v:Int) = {
     var a,b,c=0
     for(value <- values){
       if(value > v) a += 1
       else if(value == v) b += 1
       else c += 1
     }
     (a,b,c)
   }
   
   def Iteqgt1(values:Array[Int],v:Int) = {
     (values.count(_ > v),values.count(_ == v), values.count(_ < v))
   }

10.當你將兩個字符串拉鍊在一塊兒，好比"Hello".zip("World")，會是什麼結果？想出一個講得通的用例

scala> "Hello".zip("world")
res0: scala.collection.immutable.IndexedSeq[(Char, Char)] = Vector((H,w), (e,o),
 (l,r), (l,l), (o,d))