1. 程式人生 > >快學Scala習題解答—第四章 對映和元組

快學Scala習題解答—第四章 對映和元組

4 對映和元組

4.1 設定一個對映,其中包含你想要的一些裝備,以及它們的價格。然後構建另一個對映,採用同一組鍵,但是價格上打9折
對映的簡單操作 
Shell程式碼  收藏程式碼
  1. scala> val map = Map("book"->10,"gun"->18,"ipad"->1000)  
  2. map: scala.collection.immutable.Map[java.lang.String,Int] = Map(book -> 10, gun -> 18, ipad -> 1000)  
  3. scala> for((k,v) <- map) yield (k,v * 0.9
    )  
  4. res3: scala.collection.immutable.Map[java.lang.String,Double] = Map(book -> 9.0, gun -> 16.2, ipad -> 900.0)  


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

當然使用Scala的方法啦。參考第9章 
首先,建立一個檔案myfile.txt。輸入如下內容 
test test ttt test ttt t test sss s 
Scala程式碼如下 
Scala程式碼  收藏程式碼
  1. import scala.io.Source  
  2. import scala.collection.mutable.HashMap  
  3. //val source = Source.fromFile("myfile.txt")  
  4. //val tokens = source.mkString.split("\\s+")  //此寫法tokens為空,不知為何  
  5. val source = Source.fromFile("myfile.txt"
    ).mkString  
  6. val tokens = source.split("\\s+")  
  7. val map = new HashMap[String,Int]  
  8. for(key <- tokens){  
  9.     map(key) = map.getOrElse(key,0) + 1  
  10. }  
  11. println(map.mkString(","))  


4.3 重複前一個練習,這次用不可變的對映 
不可變對映與可變對映的區別就是,每次新增元素,都會返回一個新的對映

Scala程式碼  收藏程式碼
  1. import scala.io.Source  
  2. val source = Source.fromFile("myfile.txt").mkString  
  3. val tokens = source.split("\\s+")  
  4. var map = Map[String,Int]()  
  5. for(key <- tokens){  
  6.   map += (key -> (map.getOrElse(key,0) + 1))  
  7. }  
  8. println(map.mkString(","))  


4.4 重複前一個練習,這次使用已排序的對映,以便單詞可以按順序打印出來 
和上面的程式碼沒有什麼區別,只是將對映修改為SortedMap

Scala程式碼  收藏程式碼
  1. import scala.io.Source  
  2. import scala.collection.SortedMap  
  3. val source = Source.fromFile("myfile.txt").mkString  
  4. val tokens = source.split("\\s+")  
  5. var map = SortedMap[String,Int]()  
  6. for(key <- tokens){  
  7.   map += (key -> (map.getOrElse(key,0) + 1))  
  8. }  
  9. println(map.mkString(","))  


4.5 重複前一個練習,這次使用java.util.TreeMap並使之適用於Scala API
主要涉及java與scala的轉換類的使用 
Scala程式碼  收藏程式碼
  1. import scala.io.Source  
  2. import scala.collection.mutable.Map  
  3. import scala.collection.JavaConversions.mapAsScalaMap  
  4. import java.util.TreeMap  
  5. val source = Source.fromFile("myfile.txt").mkString  
  6. val tokens = source.split("\\s+")  
  7. val map:Map[String,Int] = new TreeMap[String,Int]  
  8. for(key <- tokens){  
  9.   map(key) = map.getOrElse(key,0) + 1  
  10. }  
  11. println(map.mkString(","))  


4.6 定義一個鏈式雜湊對映,將"Monday"對映到java.util.Calendar.MONDAY,依次類推加入其他日期。展示元素是以插入的順序被訪問的
LinkedHashMap的使用 
Scala程式碼  收藏程式碼
  1. import scala.collection.mutable.LinkedHashMap  
  2. import java.util.Calendar  
  3. val map = new LinkedHashMap[String,Int]  
  4. map += ("Monday"->Calendar.MONDAY)  
  5. map += ("Tuesday"->Calendar.TUESDAY)  
  6. map += ("Wednesday"->Calendar.WEDNESDAY)  
  7. map += ("Thursday"->Calendar.THURSDAY)  
  8. map += ("Friday"->Calendar.FRIDAY)  
  9. map += ("Saturday"->Calendar.SATURDAY)  
  10. map += ("Sunday"->Calendar.SUNDAY)  
  11. println(map.mkString(","))  


4.7 打印出所有Java系統屬性的表格
屬性轉scala map的使用 
Scala程式碼  收藏程式碼
  1. import scala.collection.JavaConversions.propertiesAsScalaMap  
  2. val props:scala.collection.Map[String,String] = System.getProperties()  
  3. val keys = props.keySet  
  4. val keyLengths = for( key <- keys ) yield key.length  
  5. val maxKeyLength = keyLengths.max  
  6. for(key <- keys) {  
  7.   print(key)  
  8.   print(" " * (maxKeyLength - key.length))  
  9.   print(" | ")  
  10.   println(props(key))  
  11. }  


4.8 編寫一個函式minmax(values:Array[Int]),返回陣列中最小值和最大值的對偶
Scala程式碼  收藏程式碼
  1. def minmax(values:Array[Int])={  
  2.   (values.max,values.min)  
  3. }  


4.9 編寫一個函式Iteqgt(values:Array[int],v:Int),返回陣列中小於v,等於v和大於v的數量,要求三個值一起返回
Scala程式碼  收藏程式碼
  1. def iteqgt(values:Array[Int],v:Int)={  
  2.   val buf = values.toBuffer  
  3.   (values.count(_ < v),values.count(_ == v),values.count(_ > v))  
  4. }  


4.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))  
StringOps中的zip定義如下 
abstract def zip(that: GenIterable[B]): StringOps[(A, B)] 

GenIterable是可遍歷物件需要包含的trait,對於String來說,它是可遍歷的。但是它的遍歷是遍歷單個字母。 所以拉鍊就針對每個字母來進行。

原部落格地址:http://www.ivanpig.com/blog/?p=464