Scala练习（四）

来源：互联网发布：看书软件编辑：程序博客网时间：2024/04/30 08:27

映射和元组&练习

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

映射代码如下：

objectHelloScala{
　　defmain(args: Array[String]): Unit = {
　　　　valmap=Map("Computer"->3000,"Iphone"->2000,"Cup"->10)
　　　　valfold=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

单词统计代码如下：

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valin=new Scanner(new File("src/file"))
　　　　valmaps=new HashMap [String,Int]
　　　　varkey:String=null
　　　　while(in.hasNext()){
　　　　　　key=in.next()
　　　　　　maps(key)=maps.getOrElse(key,0)+1
　　　　}　　
　　　　maps.foreach(println);
　　}
}

运行结果如下：

(Hello,3)
(Scala,1)
(World,1)

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

不可变映射代码如下：

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valin=new Scanner(new File("src/file"))
　　　　varmaps=Map[String,Int]()//注意这里如果用val声明,第18行会报错
　　　　varkey: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映射代码如下：

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valin=new Scanner(new File("src/file"))
　　　　varsortMap=SortedMap[String,Int]()
　　　　varkey: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

程序代码如下：

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valin=new Scanner(new File("src/file"))
　　　　valmap:Map[String,Int]=new TreeMap[String,Int]
　　　　varkey:String=null
　　　　while(in.hasNext()){
　　　　　　key=in.next()
　　　　　　map(key)=map.getOrElse(key,0)+1
　　　　}
　　　　map.foreach(println)
　　}
}

运行结果如下：

(Hello,3)
(Scala,1)
(World,1)

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

链式哈希映射基本使用；

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valmap=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:

objectHelloScala{
　　defmain(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])，返回数组中最小值和最大值的对偶

程序代码如下:

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valarray=Array(1,2,3,4,5)
　　　　vartuple:(Int,Int)=minmax(array)
　　　　println(tuple._1+" "+tuple._2)
　　}
　　defminmax(arr:Array[Int])={
　　　　(arr.min,arr.max)
　　}
}

运行结果:

1 5

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

程序代码如下:

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valarray=Array(1,1,2,2,3,3,4,5,6)
　　　　valtuple:(Int,Int,Int)=iteqgt(array,3)
　　　　println("大于3的数量:"+tuple._1)
　　　　println("等于3的数量:"+tuple._2)
　　　　println("小于3的数量:"+tuple._3)
　　}
　　defiteqgt(arr:Array[Int],v:Int)={
　　　　valbuf=arr.toBuffer
　　　　(buf.count(_< v),buf.count(_== v),buf.count(_>= v))
　　}
}

运行结果:

大于3的数量:4
等于3的数量:2
小于3的数量:5

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

程序代码：

objectHelloScala{
　　defmain(args: Array[String]): Unit= {
　　　　valtuple="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来说，它是可遍历的。但是它的遍历是遍历单个字母。所以拉链就针对每个字母来进行

0 0