Scala学习(四)练习

时间:2023-12-24 23:12:37

映射和元组&练习

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】。

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