快学scala 第四章 读书笔记及习题答案代码

chapter 4 元组与映射

标签：快学scala

---

一、笔记

1. 默认Map为不可变映射，可变映射定义：

 
 
scala> val scores = scala.collection.mutable.Map("Allic"->1, "Bob"->3, "Cindy"->8)
scala> val scores = new scala.collection.mutable.HashMap[String, Int]   //空映射  
scores: scala.collection.mutable.HashMap[String,Int] = Map()

获取map中的值：

 
 
scala> val bobscore = scores("Bob")
bobscore: Int = 3
scala> val bobscore = if(scores.contains("Bob")) scores("Bob") else 0  //检查操作
bobscore: Int = 3
//简写
scala> val bobscore = scores.getOrElse("Bob",0)
bobscore: Int = 3
//更新操作
scala> val newscore = scores + (("Bob", 10),("Fred", 7))
newscore: scala.collection.mutable.Map[String,Int] = Map(Allic -> 1, Bob -> 10, Fred -> 7, Cindy -> 8)

1. 迭代映射 scores.keyset 关键字的集合; socres.value值 
   for(v <- scores.values) println(v) 
   for((k, v) <- socres) yield(v,k) //反转映射
2. 键值是键/值对偶的集合，对偶是元组的最简单形式，tuple是不同类型的值的聚集。元组的各组员从1开始，而不是0. 元组可以用于函数需要返回不止一个值的情况：

 
 
scala> "New York".partition(_.isUpper)
res2: (String, String) = (NY,ew ork)

1. 拉链操作

 
 
scala> "New York".partition(_.isUpper)
res2: (String, String) = (NY,ew ork)
scala> val symbols=Array("<", "-",">")
symbols: Array[String] = Array(<, -, >)
scala> val counts = Array(2,10,2)
counts: Array[Int] = Array(2, 10, 2)
scala> val pairs= symbols.zip(counts)
pairs: Array[(String, Int)] = Array((<,2), (-,10), (>,2))
scala> for((s,n)<- pairs)Console.print(s * n)
<<---------->>

二、习题答案

4.1 设置一个映射,其中包含你想要的一些装备，以及它们的价格。然后构建另一个映射，采用同一组键，但是价格上打9折

 
 
def equipment(): Map[String, Double]={
        val equipmap :Map[String, Double] = Map(("eq1",10.8),("eq2",12.2),("eq3",13.3))
        for((n,k) <- equipmap) yield(n,k*0.9)
}
println(equipment().mkString(","))

4.2 编写一段程序，从文件中读取单词。用一个可变映射来清点每个单词出现的频率。读取这些单词的操作可以使用java.util.Scanner

 
 
import scala.io.Source
import scala.collection.mutable.HashMap
val source = Source.fromFile("test.txt").mkString
println(source)
val tokens = source.split("\\s+")   //"\\s"表示空格 回车 换行符 “+”表示多个的意思
val map = new HashMap[String,Int]
for(key <- tokens){
    map(key) = map.getOrElse(key,0) + 1
}
println(map.mkString(","))

4.3 重复前一个练习，这次用不可变的映射

 
 
import scala.io.Source
val source = Source.fromFile("test.txt").mkString
val tokens = source.split("\\s+")
var map = Map[String,Int]()
for(key <- tokens){
  map += (key -> (map.getOrElse(key,0) + 1))
}
println(map.mkString(","))

4.4 重复前一个练习，这次使用已排序的映射，以便单词可以按顺序打印出来

 
 
import scala.io.Source
import scala.collection.immutable.TreeMap
val source = Source.fromFile("test.txt").mkString
val tokens = source.split("\\s+")
var map = new TreeMap[String,Int]()
for(key <- tokens){
  map += (key -> (map.getOrElse(key,0) + 1))
}
println(map.mkString(",")

4.5 重复前一个练习，这次使用java.util.TreeMap并使之适用于Scala API

 
 
import scala.io.Source
import scala.collection.JavaConversions.mapAsScalaMap
val source = Source.fromFile("test.txt").mkString
val tokens = source.split("\\s+")
var map = new sortedMap[String,Int]()
for(key <- tokens){
  map += (key -> (map.getOrElse(key,0) + 1))
}
println(map.mkString(","))

4.6 定义一个链式哈希映射,将”Monday”映射到java.util.Calendar.MONDAY,依次类推加入其他日期。展示元素是以插入的顺序被访问的

 
 
import java.util.Calendar
import scala.collection.mutable
def calendarDays(): Unit={
        val daysMap = mutable.LinkedHashMap(
                        "Monday" -> Calendar.MONDAY,
                        "Tuesday" -> Calendar.TUESDAY,
                        "Wednesday" -> Calendar.WEDNESDAY,
                        "Thursday" -> Calendar.THURSDAY,
                        "Friday" -> Calendar.FRIDAY,
                        "Saturday" -> Calendar.SATURDAY,
                        "Sunday" -> Calendar.SUNDAY
        )
        println(daysMap.mkString(","))
}
calendarDays()

4.7 打印出所有Java系统属性的表格

 
 
import scala.collection.JavaConversions.propertiesAsScalaMap
def printJavaSysProps():Unit = {
        val propMap:collection.Map[String,String] = System.getProperties()
                val maxKeyLength = propMap.keySet.map(_.length).max
                for( (k,v) <- propMap ) printf("%-" + maxKeyLength + "s | %s\n", k, v)          
}

4.8 编写一个函数minmax(values:Array[Int]),返回数组中最小值和最大值的对偶

 
 
def minmax(values: Array[Int]) = {
        (values.min, values.max)
}
val arr = Array(1,2,3,4,5)
println(minmax(arr).toString)

4.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))
}
val arr = Array(1,2,3,4,5)
println(Iteqgt(arr, 3).toString)

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定义如下:
def zip[B](that: GenIterable[B]): StringOps[(A, B)]

GenIterable是可遍历对象需要包含的trait，对于String来说，它是可遍历的。但是它的遍历是遍历单个字母。所以拉链就针对每个字母来进行。