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(key)=maps.getOrElse(key, 0)+1
}
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 maps=Map[String,Int]()//注意這裡如果用val宣告,第18行會報錯
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(key)=map.getOrElse(key, 0)+1
}
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)
println("大於3的數量:"+tuple._1)
println("等於3的數量:"+tuple._2)
println("小於3的數量:"+tuple._3)
}
def iteqgt(arr:Array[Int],v:Int)={
val buf=arr.toBuffer
(buf.count(_ < v),buf.count(_ == v),buf.count(_ >= v))
}
}
執行結果:
大於3的數量:4
等於3的數量:2
小於3的數量: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來說，它是可遍歷的。但是它的遍歷是遍歷單個字母。 所以拉鍊就針對每個字母來進行