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來講，它是可遍歷的。可是它的遍歷是遍歷單個字母。 因此拉鍊就針對每一個字母來進行

若是，您認爲閱讀這篇博客讓您有些收穫，不妨點擊一下右下角的【推薦】。
若是，您但願更容易地發現個人新博客，不妨點擊一下左下角的【關注我】。
若是，您對個人博客所講述的內容有興趣，請繼續關注個人後續博客，我是【Sunddenly】。

本文版權歸做者和博客園共有，歡迎轉載，但未經做者贊成必須保留此段聲明，且在文章頁面明顯位置給出原文鏈接，不然保留追究法律責任的權利。