1.設定一個對映，其中包含你想要的一些裝備，以及它們的價格。然後構建另一個對映，採用同一組鍵，但在價格上打9折。

val item = Map(("computer"->4500.0),("keyboard"->291.0))
val itemDiscount = for((k,v)<- item) yield(k,v*0.9)

2.編寫一段程式，從檔案中讀取單詞。用一個可變對映來清點每一個單詞出現的頻率。

讀取這些單詞的操作可以用java.util.Scanner

val word = new scala.collection.mutable.HashMap[String,Int]
val in
 
 = new java.util.Scanner(new java.io.File("myfile.txt"))
while (in.hasNext()){
    val key = in.next()
    word(key) = word.getOrElse(key,0) + 1
}
println(word)

3.重複前一個練習，這次用不可變的對映。

var word2 = Map[String,Int]()
val in2 = new java.util.Scanner(new java.io.File("myfile.txt"))
while(in2.hasNext()){
    val key = in2.next
 
()
    word2 += (key -> (word2(key).getOrElse(key,0)+1))
}
println(word2)

4.重複前一個練習，這次用已排序的對映，以便單詞可以按順序打印出來。

var word3 = scala.collect.immutable.SortedMap[String,Int]()
val in3 = new java.util.Scanner(new java.io.File("myfile.txt"))
while(in3.hasNext()){
     val key = in3.next()
     word3 += (key->(word3.getOrElse
 
(key,0) + 1))
}
println(word3)

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

import scala.collection.JavaConversions.mapAsScalaMap

val word4:scala.collection.mutable.Map[String,Int]=new java.util.TreeMap[String,Int]

val in4 = new java.util.Scanner(new java.io.File("myfile.txt"))
while(in4.hasNext()){
  val key = in4.next()
  word4 += (key->(word3.getOrElse(key,0) + 1))
}
println(word4)

6.定義一個鏈式雜湊對映，將”Monday”對映到java.util.Calendar.MONDAY, 以此類推加入其他日期。展示元素是以插入的順序被訪問的。

val calendar = new mutable.LinkedHashMap[String,Int]
calendar += ("Monday" -> java.util.Calendar.MONDAY)
calendar += ("Tuesday" -> java.util.Calendar.TUESDAY)
calendar += ("Wednesday" -> java.util.Calendar.WEDNESDAY)
calendar += ("Thursday" -> java.util.Calendar.THURSDAY)
calendar += ("Friday" -> java.util.Calendar.FRIDAY)
calendar += ("Saturday" -> java.util.Calendar.SATURDAY)
calendar += ("Sunday" -> java.util.Calendar.SUNDAY)
println(java.util.Calendar.MONDAY)
println(calendar)

7.打印出所有Java系統屬性的表格

類似這樣：

java.rutime.name                   | Java(TM) SE Runtime Environment
sun.boot.library.path              | /home/apps/jdk1.6.0_21/jre/lib/i386
java.vm.version                    | 17.0-b16
java.vm.vendor                     | Sun Mocrosystems Inc.
java.vendor.url                    | http://java.sun.com/
path.separator                     | :
java.vm.name                       | Java HotSpot(TM) Server VM

你需要找到最長鍵的長度才能正確的打印出這張表格。

import scala.collection.JavaConversions.propertiesAsScalaMap
val properties:scala.collection.Map[String,String] = System.getProperties.take(10)
val keyMaxLength = (for(key <- properties.keySet) yield key.length).max
properties.foreach{
  case (a,b)=>println(a+" "*(keyMaxLength-a.length)+ "|" + b)
}

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)={
(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)) 

StringOps中的zip定義如下：

abstract def zip[B](that:GenIterable[B]):StringOps[(A,B)]

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