Scala学习(四)练习

映射和元组&练习

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

映射代码如下：

object HelloScala{

　　def main(args: Array[String]): Unit = {

　　　　val map=Map("Computer"->3000,"Iphone"->2000,"Cup"->10)

　　　　val fold=for((k,v)<-map) yield (k,v*0.9)

　　　　fold.foreach(println)

　　}

}

运行结果：

(Computer,2700.0)

(Iphone,1800.0)

(Cup,9.0)

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

val in=new java.util.Scanner(new java.io.File("myfile.txt"))

while　　(in.hasNext()) 处理in .next()

最后，打印出所有单词和它们出现的次数

首先，新建一个file文件，文件名为：file，文件内容如下：

Hello    Hello

World    Hello    Scala

单词统计代码如下：

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val in=new Scanner(new File("src/file"))

　　　　val maps=new HashMap [String,Int]

　　　　var key:String=null

　　　　while(in.hasNext()){

　　　　　　key=in.next()

　　　　}　　

　　　　maps.foreach(println);

　　}

}

运行结果如下：

(Hello,3)

(Scala,1)

(World,1)

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

不可变映射代码如下：

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val in=new Scanner(new File("src/file"))

行会报错

　　　　var key:String=null

　　　　while(in.hasNext()){

　　　　　　key=in.next()

　　　　　　maps+=(key->(maps.getOrElse(key, 0)+1))

　　　　}

　　　　maps.foreach(println)

　　}

}

运行结果：

(Hello,3)

(Scala,1)

(World,1)

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

使用SortedMap映射代码如下：

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val in=new Scanner(new File("src/file"))

　　　　var sortMap=SortedMap[String,Int]()

　　　　var key:String=null

　　　　while(in.hasNext()){

　　　　　　key=in.next()

　　　　　　sortMap+=(key->(sortMap.getOrElse(key, 0)+1))

　　　　}

　　　　sortMap.foreach(println)

　　}

}

运行结果：

(Hello,3)

(Scala,1)

(World,1)

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

程序代码如下：

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val in=new Scanner(new File("src/file"))

　　　　val map:Map[String,Int]=new TreeMap[String,Int]

　　　　var key:String=null

　　　　while(in.hasNext()){

　　　　　　key=in.next()

　　　　}

　　　　map.foreach(println)

　　}

}

运行结果如下：

(Hello,3)

(Scala,1)

(World,1)

6. 定义一个链式哈希映射，将＂Monday＂映射java.utiI.Calendar.MONDAY，依此类推加入其他日期。展示元素是以插入的顺序被访问的

链式哈希映射基本使用；

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val map=new LinkedHashMap[String,Int]

　　　　map+=("Monday"->Calendar.MONDAY)

　　　　map+=("Tuesday"->Calendar.TUESDAY)

　　　　map+=("Thursday"->Calendar.THURSDAY)

　　　　map+=("Wednesday"->Calendar.WEDNESDAY)

　　　　map+=("Friday"->Calendar.FRIDAY)

　　　　map+=("Saturday"->Calendar.SATURDAY)

　　　　map+=("Sunday"->Calendar.SUNDAY)

　　　　map.foreach(println)

　　}

}

运行结果:

(Monday,2)

(Tuesday,3)

(Thursday,5)

(Wednesday,4)

(Friday,6)

(Saturday,7)

(Sunday,1)

7. 打印出所有Java系统属性的表格，类似这样：

　　java.runtime.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 Microsystems Inc.

java.vendor.url 　　　　　 　　　　　　　　　　　　　　　　　　 | http://java.sun*com/

path.separator　　　　　　　　　　　　　　　　　　　　　　　　 |：

java.vm.name　　　　　　　　　　　　　　　　　　　　　　　　  |　　Java HotSpot (TM)　　Server VM

你需要找到最长键的长度才能正确地打印出这张表格

属性转ScalaMap:

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　 val props:scala.collection.Map[String,String]=System.getProperties()

　　 val keys=props.keySet

　　 val keylens=for(i<-keys) yield i.length()

　　 val keymaxlen=keylens.max

　　 for(key <- keys){

　　　　 print(key)

　　　　 print(" "*(keymaxlen-key.length()))

　　　　 print("|")

　　　　 println(props(key))

　　 }

　　}

}

运行结果:

java.runtime.name　　　　　　　　　　　　|Java(TM) SE Runtime Environment

sun.boot.library.path　　　　　　　　    |F:\Tools\DevelopTool\Jre1.7\bin

java.vm.version　　　　　　　　　　　　　 |24.72-b04

java.vm.vendor　　　　　　　　　　　　　　|Oracle Corporation

java.vendor.url　　　　　　　　　　　　　 |http://java.oracle.com/

path.separator　　　　　　　　　　　　　　|;

java.vm.name　　　　　　　　　　　　　　　 |Java HotSpot(TM) Client VM

file.encoding.pkg　　　　　　　　　　　　 |sun.io

8. 编写一个函数minmax(values: Array[lnt])，返回数组中最小值和最大值的对偶

程序代码如下:

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val array=Array(1,2,3,4,5)

　　　　var tuple:(Int,Int)=minmax(array)

　　　　println(tuple._1+" "+tuple._2)

　　}

　　def minmax(arr:Array[Int])={

　　　　(arr.min,arr.max)

　　}

}

运行结果:

1 5

9. 编写一个函数lteqgt(values: Array[lnt]，v：Int)，返回数组中小于v、等于v和大于V的数量，要求三个值一起返回

程序代码如下:

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val array=Array(1,1,2,2,3,3,4,5,6)

　　　　val tuple:(Int,Int,Int)=iteqgt(array,3)

的数量:"+tuple._1)

的数量:"+tuple._2)

的数量:"+tuple._3)

　　}

　　def iteqgt(arr:Array[Int],v:Int)={

　　　　val buf=arr.toBuffer

　　　　(buf.count(_ < v),buf.count(_ == v),buf.count(_ >= v))

　　}

}

运行结果:

的数量:4

的数量:2

的数量:5

10. 当你将两个字符串拉链在一起，比如＂Hello＂.zip(＂World＂)，会是什么结果，想出一个讲得通的用例

程序代码：

object HelloScala{

　　def main(args: Array[String]): Unit= {

　　　　val tuple="Hello".zip("World")

　　　　tuple.toMap

　　　　tuple.foreach(println)

　　}

}

运行结果：

(H,W)

(e,o)

(l,r)

(l,l)

(o,d)

在Scaladoc的StringOps中的zip方法定义如下:

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

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

如果，您认为阅读这篇博客让您有些收获，不妨点击一下右下角的【推荐】。
如果，您希望更容易地发现我的新博客，不妨点击一下左下角的【关注我】。
如果，您对我的博客所讲述的内容有兴趣，请继续关注我的后续博客，我是【Sunddenly】。

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。