|
映射和元组&练习 |
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】。本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。