囉嗦

這個不是標準答案，只是我自己根據本章內容實現了練習的目的，也不是最優解。

練習1 產生一個包含所有字元的下標的對映

例如：”Mississippi” 應該生成 ‘M’->{0},’i’->{1,4,7,10}，以此類推。

這個我還是花了點時間，一直沒想到好的解決辦法，我覺得我的辦法還可以再優化一下！
他問怎樣保證集是排序過的，我反正順序訪問和追加一定是排序過的

    //練習 1 LX13_1
    //集由於順序訪問和追加一定是排序的
    def LX13_1(s: String): scala.collection.mutable.Map[Char, Set[Int
 
]] = {
        var tmpMap =scala.collection.mutable.Map[Char, Set[Int]]()
        s.zipWithIndex.foreach(i =>{
            tmpMap(i._1)= tmpMap.getOrElse(i._1,Set[Int]())+(i._2)
        })
        tmpMap
    }
    //測試函式
     LX13_1("Mississippi").foreach(i=>{
     //println(i._1+" "+i._2.mkString("{",",","}"))
 

//         M {0}
//         s {2,3,5,6}
//         p {8,9}
//         i {1,4,7,10}
 })

練習2 把練習1的集變成列表，同樣是產生對映

偷懶的實現了，順序是反序的，reverse很簡單

//練習2 LX13_2
    //偷懶 得到的是反序的
    def LX13_2(s:String):scala.collection.mutable.Map[Char,List[Int]]={
        var tmpMap =scala.collection.mutable.Map[Char, List[Int]]()
        s.
 
zipWithIndex.foreach(i =>{
            tmpMap(i._1)= i._2::tmpMap.getOrElse(i._1,List[Int]())
        })
        tmpMap
    }
    //測試函式
    LX13_2("Mississippi").foreach(i=>{
        println(i._1+" "+i._2.mkString("{",",","}"))
    })

練習3 從整形連結串列中去除所有的0

LinkedList已經不建議使用了。。。

 //練習3 LX13_3
    //這是我能想到的比較合理的實現 不過linkedlist已經不贊成使用了
    import scala.collection.mutable.LinkedList
    def LX13_3(linkedList:LinkedList[Int]):LinkedList[Int]={
        var tmp=linkedList
        var res=LinkedList[Int]()
        while(tmp !=Nil){
            if(tmp.elem!=0){
                res=res++LinkedList(tmp.elem)
            }
            tmp=tmp.next
        }
        res
    }
//    LX13_3(LinkedList(1,2,0,3,4,0,5,6,0,1)).foreach(println(_))
//    LX13_3(LinkedList(1,2,0,3,4,0,5,6,0)).foreach(println(_))
//    LX13_3(LinkedList(1,2,0,0,4,0,5,6,0)).foreach(println(_))

練習4 從一個字串的陣列中去匹配一個[String,Int]的Map，將值也就是Int再生成一個集返回

一般來說，首先考慮的回事getOrElse，不過我直接先filter，這樣子就不需要判斷是否有值了

def LX13_4(name:Array[String],nameM:Map[String,Int])={
       var res=Set[Int]()
       name.filter(i=>{nameM.keys.toList.contains(i)}).foreach(i=>{res=res++nameM.get(i).toList})
       res
   }
    val nameArr=Array("scala","spark","flink")
    val nameMap=Map("scala"->1,"flink"->2)
   println(LX13_4(nameArr,nameMap).mkString("(",",",")"))

練習5 用reduceLeft實現一個mkString相似的函式，我沒有用trait去混入，就寫了個函式

這個比較簡單，一直重寫就行。

def LX13_5(seq:Seq[Any]):String={
        seq.reduceLeft(_+""+_).toString
    }
    def LX13_5(seq:Seq[Any],str:String):String={
        seq.reduceLeft(_+str+_).toString
    }
    def LX13_5(seq:Seq[Any],start:String,str:String,end:String):String={
        start+seq.reduceLeft(_+str+_).toString+end
    }
    val tmpList=List[Int](1,2,3,4,5,6)
//    println(LX13_5(tmpList))
    //    println(LX13_5(tmpList,"+"))
      println(LX13_5(tmpList,"{",",","}"))

練習6 利用(List[Int]()/:tmpList2)(_ :+ _)或者(List[Int]()/:tmpList2)(_ :+ _)反序一個list

原題首先問了(List[Int]()/:tmpList2)(_ :+ _)和 (List[Int]()/:tmpList2)(_ :+ _) 會有什麼結果 結果是一樣的順序序列，不一樣的表達而已
自己太懶了。。。

  //練習6
    val tmpList2=List(1,2,3,4,4,5,6,7,7)
    //兩個結果一樣 只不過是不同的表達方式而已
    //都是重新建了一個一樣的list
  (tmpList2:\List[Int]())(_ :: _).foreach(println(_))
  (List[Int]()/:tmpList2)(_ :+ _).foreach(println(_))
    //修改 反序
    //終極偷懶方式。。。哈哈哈哈哈
 (List[Int]()/:tmpList2.toVector.reverse.toList)((a,b)=>{a:+b}).foreach(println(_))

練習7 利用Function.tuple實現map接受一個元組

之前12章寫過一個這樣的函式，Function.tuple可以直接實現,不過我不是很確定是不是需要隱式轉換，因為我這樣寫也不是很”優雅”

     val prices=List(5.0,20.0,9.95)
    val quantities=List(10,2,1)
    //12章的時候已經寫過一個了  貌似這個直接就可以 坑啊。。
   (prices zip quantities).map(Function.tupled(_ * _)).foreach(println(_))

練習8 Double陣列轉換成N維陣列

使用group可以直接實現

    //練習8 LX13_8
    def LX13_8(doubleArr:Array[Double],num:Int)={
        doubleArr.grouped(num)
    }
    val tmpArr=Array[Double](2.00,3.12,3.123,5.2,234,123.123)
  LX13_8(tmpArr,3).foreach(i=>i.foreach(println(_)))

9 和 10我就不寫出來了，沒啥寫的

程式碼

我在碼雲存了一份程式碼片段：

碼雲可以存程式碼片段這個還是很不錯的，github沒有這個功能