快学Scala 第四章习题答案

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来说，它是可遍历的。但是它的遍历是遍历单个字母。所以拉链就针对每个字母来进行。