前言：Scala的安裝教程：http://www.cnblogs.com/biehongli/p/8065679.html

1：Scala之基礎語法學習筆記：

1:聲明val變量:可以使用val來聲明變量，用來存放表達式的計算結果，但是常量聲明後是無法改變它的值的，建議使用val來聲明常量；
  聲明var變量:如果要聲明可以改變的引用，可以使用var變量，聲明的常量的值可以改變。
3:指定類型:無論聲明val變量還是聲明var變量。都可以手動指定其類型，如果不指定，scala會自動根據值，進行類型的推斷；
4:聲明多個變量:可以將多個變量放到一起進行聲明,如val id,age :Int = 0
 
;val num1,num2=100;
5:基礎數據類型:Byte,Char,Short,Int,Long,Float,Double,Boolean;記住，Scala沒有包裝數據類型；
6:基本操作符:scala的算術操作符和Java的算術操作符沒有什麽區別，比如+ - * / %等等，以及其他操作符，& | >> << 等等，但是在scala中，這些操作符其實是數據類型的函數，比如1+1,可以寫作1.+(1),1 to 10可以寫作1.to(10)等等。
　　  註意，在scala中沒有提供++,--操作，我們只可以使用+=和-=操作符；
7:apply函數:在scala中apply函數是非常特殊的一種函數，在Scala的object中，可以聲明apply函數。而使用"類名()"的形式，其實就是"類名.apply()"的一種縮寫。通常使用這種方式來構造類的對象，而不是使用"new 類名()"的方式。
 
　　 比如"hello world"(6)可以寫成"hello world".apply(6)；

2：Scala之條件控制學習筆記：

1:if表達式的定義:在scala中，if表達式是有值的，就是if或者else中最後一行就是返回的值。
    比如var age = 18; if(age >18) 1 else 0;
    可以將if表達式賦予一個變量，比如var result = if(age >18) 1 else 0;
2:if表達式的類型推斷，由於if表達式是有值的，而if和else子句的值類型可能是不同的。此時if表達式的值是什麽類型的呢，scala可以自動進行推斷，取兩個類型的公共父類型。
    比如：
 
var age =18;if(age > 18) "成年人" else 0;此時if和else的值分別是String和Int,則表達式的值就是Any,因為Any是String和Int的公共父類型。
3:如果if後面沒有跟else，則默認else的值是Unit，也可以用()表示，類似於Java中的void或者null。
4:語句終結符:默認情況下，scala不需要語句終結符即;這個分號,默認每一行作為一個語句。
    但是如果一行放多條語句，則必須使用語句終結符。
5:塊表達式。指的就是{}中的值，其中可以包含多條語句，最後一個語句的值就是塊表達式的返回值。
6:輸出:print()和println(),其中print()打印的時候不會加換行，但是println()打印的時候會加一個換行符。
7:輸入:readLine：允許我們從控制臺讀取用戶輸入的數據，類似於Java中的System.in和Scanner的作用。
    註意:readInt()輸入是數值類型的。readDouble()是輸入小數類型的。

3：Scala之循環控制學習筆記：

1:while do循環，scala中的while do循環，基本和Java相同。
2:for循環，比如:for(i <- 1 to 10) println(i);註意for循環的使用，多加揣摩和練習。
3:跳出循環語句:scala中沒有提供如Java中的跳出循環語句。但是可以使用boolean類型變量，return或者使用Breaks的break函數來替換使用。
    比如：var flag : Boolean = false;for(i <- 1.to(10)) if(i%2==0){ flag = true; return flag;}
4:scala的九九乘法表:
    for(i <- 1.to(9); j <- 1.to(9)){
      if(j == 9){
        println(i + "*" + j + " = " + i*j);
      }else{
        print(i + "*" + j + " = " + i*j + " ");
      }

    }
5:scala的取偶數
    for(i <- 1 to 100 if i % 2 ==0) println(i)
6:for推導式，構造集合:
    var a = for(i <- 1 to 10) yield i;
    println(a)

4：Scala之函數學習筆記，面向對象和面向函數編程：

1:函數的定義:需要定義函數的函數名，參數，函數體；Scala要求必須給出所有參數的類型，但是不一定給出函數返回值的類型，只要右側的函數體中不包含遞歸的語句，Scala就可以根據自己右側的表達式推斷出返回類型。
    比如：
    def helloScala(name : String,age : Int): Unit ={
      if(age > 18){
         println("恭喜您:" + name + "您已經:" + age+"歲了，您已經成年了");
      }else{
        println("恭喜您:" + name + "您已經:" + age+"歲了，您還是未成年哦");
      }
    }
    helloScala("張三",20);
2:如果在函數體遞歸調用函數自身，則必須手動給出函數的返回值類型。
3:默認參數，在Scala中，有時候在調用某些函數的時候，不希望給出參數的具體指，而希望使用參數自身默認的值，此時就在定義函數時使用默認參數。如果給出的參數不夠，則會從左往右依次應用參數。
    比如:
    def hello(name :String="張三",age : Int=20): Unit ={
      println(name+ " "  + age)
    }
    hello()
4:帶名參數:在調用函數的時候，也可以不按照函數定義的參數順序來傳遞參數，而是使用帶名參數的方式來傳遞；
    還可以混合使用未命名參數和帶名參數，但是未命名參數必須在帶名參數前面。
    比如：
    def hello(name :String="張三",age : Int=20): Unit ={
      println(name+ " "  + age)
    }
    hello(age=24,name="李四")
    hello("王五",age=26)
5:函數之變長參數:在Scala中，有時候我們需要將函數定義為參數個數可變的形式，則此時可以使用變長參數定義函數:
    比如:
    def add(nums : Int*): Int ={
      var sum : Int= 0;
      for(num <- nums){
        sum += num;
      }
      return sum;
    }
    var result = add(1,2,3,4);
    println(result)
註意:如果想要將一個已有的序列直接調用變長參數，是不可以的。此時需要使用Scala特殊的語法將參數定義為序列，讓Scala解釋器能夠識別:比如:var s = sum(1 to 5:_*)
    比如:
    def add(nums : Int*): Int ={
      var sum : Int= 0;
      for(num <- nums){
        sum += num;
      }
      return sum;
    }
    println(add(1 to 4:_*))
6：函數之過程，定義函數的時候，如果函數體直接包裹在了花括號裏面，而沒有使用=連接，則函數的返回值就是Unit。這樣的函數就被稱之為過程。過程通常用於不需要返回值的函數。
註意:過程還有一種寫法，就是將函數的返回值類型定義為Unit;
    比如：
        def hello(name : String) = "hello:" +name;
        def hello(name : String) {println("hello:"+name);"hello:"+ name}
        def hello(name : String) : Unit= "hello:" +name;    
7：Scala的異常:在scala中，異常處理和捕獲機制與Java類似。
    比如：
    try{
      throw new IllegalArgumentException("算數異常");
    }catch{
      case _:IllegalArgumentException => println("算術異常");
    }finally {
      println("最後一定執行這句話。")
    }

4：Scala之數組學習筆記：

1:Array,在Scala中，Array也是長度可變的數組，此外，由於Scala與Java都是運行在Jvm中，雙方可以互相調用，因此，Scala數組的底層實際上就是Java數組。
    比如:數組初始化以後，長度就固定下來了，而且元素全部根據其類型初始化:
        var arr = new Array[Int](10)
        var arr2 = new Array[String](10)
    可以直接使用Array()創建數組，元素類型自動推斷:
        var arr = Array("張三","李四");
        println(arr(0))
2:ArrayBuffer,在Scala中，如果需要類似於Java中ArrayList這種長度可變的集合類，則可以使用ArrayBuffer;
    如果不想每次都使用全限定名，則可以預先導入ArrayBuffer類:
        import scala.collection.mutable.ArrayBuffer
    使用ArrayBuffer()方式可以創建一個空的ArrayBuffer:
        var arr = ArrayBuffer[Int]();
        println(arr.toBuffer)        
    使用+=操作符，可以添加一個元素或者多個元素:
        arr += 1;
        println(arr.toBuffer)
        arr += (2,3,4,5,6);
        println(arr.toBuffer)    
    使用++=操作符，可以添加其他集合中的所有元素:
        arr ++= Array(8,9,5,6,3,66);
        println(arr.toBuffer)
    使用trimEnd()函數，可以從尾部截斷指定個數的元素:
        arr.trimEnd(5)
        println(arr.toBuffer)
    使用insert()函數可以在指定位置插入元素。但是這種操作效率很低，因為需要移動指定位置後的所有元素。
    使用remove()函數可以移除指定位置的元素。    
    Array和ArrayBuffer可以互相進行轉換:arr.toArray;arr.toBuffer    
3:遍歷Array和ArrayBuffer
    使用for循環和until遍歷Array和ArrayBuffer：
    使用until是RichInt提供的函數:
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- 0.until(arr.length)){
          print(arr(i) + " ")
        }
    跳躍遍歷Array/ArrayBuffer
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- 0.until(arr.length,3)){
          print(arr(i) + " ")
        }
    從尾部遍歷Array/ArrayBuffer
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- 0.until(arr.length).reverse){
          print(arr(i) + " ")
        }
    使用增強for循環遍歷Array/ArrayBuffer
        var arr = Array(11,22,33,44,55,66,77,88);
        for(i <- arr){
          print(i + " ")
        }    
4：數組的常用函數：
    數組元素求和:
        var arr = Array(55,11,22,33,44,55,66,77,88);
        println("求和：" + arr.sum)        
    獲取數組的最大值和最小值:
        println("最大值:"+ arr.max + " ,最小值:" + arr.min)            
    對數組進行排序:
        quickSort(arr)
        println("排序:"+ arr.toBuffer)        
    獲取數組中所有的元素內容:
        println("獲取值："+ arr.mkString(","))
    toString函數
        println(arr.toString)
5:使用yield和函數式編程轉換數組:
    對數組Array進行轉換，獲取的還是Array：
        var arr = Array(11,12,13,14,15,16,17,18,19);
        var result = for(i <- arr) yield i * i;
        for(i <- result){
          print(i + " ")
        }        
    對數組ArrayBuffer進行轉換，獲取的還是ArrayBuffer：    
        var arr = ArrayBuffer[Int]();
        arr += (11,12,13,14,15,16,17,18,19);
        var result = for(i <- arr) yield i * i;
        for(i <- result){
          print(i + " ")
        }
    結合if守衛，僅僅轉換需要的元素:
        var arr = ArrayBuffer[Int]();
        arr += (11,12,13,14,15,16,17,18,19);
        var result = for(i <- arr if i %2 == 0) yield i * i;
        for(i <- result){
          print(i + " ")
        }    
    使用函數式編程轉換數組,通常使用第一種方式:    
        var arr = ArrayBuffer[Int]();
        arr += (11,12,13,14,15,16,17,18,19);
        var result = arr.filter(_ % 2 == 0).map(2 * _)
        print(result.toBuffer + " ")
        var result2 = arr.filter(_ % 2 == 0) map{2 * _}
        print(result2.toBuffer + " ")
        

5：Scala之集合中的Map，以及tuple的學習筆記：

1:創建Map:
    創建一個不可變的Map:
        import scala.collection.immutable.Map
        var map = Map("張三" ->26,"李思思" -> 23);
        println(map("張三"))
    創建一個可變的Map:
        import scala.collection.mutable.Map
        var map = Map("張三" -> 23,"李思思" -> 24);
        println(map("張三"))
        map("王五") = 25;
        println(map("王五"))    
    使用另外一種方式定義Map元素:
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        println(map.toBuffer)
    創建一個空的HashMap:
        var map = new mutable.HashMap[String,Int]()
    獲取指定key對應的value，如果key不存在，會報錯的:    
        println(map("張三"))
    使用contains函數檢查key是否存在:
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        if(map.contains("張三")){
          println("張三存在");
        }else{
          println("張三不存在");
        }        
    使用getOrElse函數用來判斷是否存在，不存在返回一個默認值:
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        var result = map.getOrElse("張三三",20)
        println(result)
    更新Map的元素:
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        map("張三") = 26;
        println(map("張三"))
    增加多個元素：
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        map += ("小明" -> 22,"小紅" -> 26);
        println(map.toBuffer)
    移除元素:
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        map -= "張三";
        println(map.toBuffer);
    更新不可變的map：
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        map -= "張三";//而不是map不可以添加和減少對應的key-value
        //map("李四") = 20;//註意不可更改是key對應的value不可以改變。
        println(map.toBuffer);
        map += ("張三" -> 26);
        println(map.toBuffer)
    移除不可變的map的元素:
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        var map2 = map + ("小紅" -> 20,"小明" -> 21);
        println(map2.toBuffer)
        var map3 = map2 - ("小紅","小明");
        println(map3.toBuffer)
2:Scala遍歷Map的操作：    
    scala遍歷map的entrySet：
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        for((key,value) <- map){
        println(key + " " + value)
        }
    scala遍歷map的key：
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        for(key <- map.keySet){
        println(key + " " + map(key))
        }
    scala遍歷map的value：
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        for(value <- map.values){
          println(value)
        }
    scala生成新的map，反轉key和value：
        var map = Map(("張三",22),("李四",23),("王五",24),("趙六",26));
        var result = for((key,value) <- map) yield (value,key)
        for((key,value) <- result){
          println(key + " " + value)
        }
    SortedMap可以自動對Map的key進行排序:
        var map = SortedMap("張三" -> 26, "別先生" -> 24 ,"小明" ->20);
        println(map.toBuffer)
    LinkedHashMap可以記住插入的entry的順序:
        var map = new mutable.LinkedHashMap[String ,Int]();
        map("張三") = 20;
        map("別先生") = 24;
        map("小明") = 22;
        println(map.toBuffer)
        for((key,value) <- map){
          println(key + " " + value)
        }
3:scala的tuple：    
    簡單Tuple和訪問Tuple：
        var tuple = ("張三",26,20,true,"李四");
        println(tuple._1)
        println(tuple._2)
        println(tuple._3)
        println(tuple._4)
        println(tuple._5)
    zip操作:
        var names = Array("張三","李四","王五");
        var ages = Array(24,25,26);
        var result = names.zip(ages);
        println(result.toBuffer)
        for((name,age) <- result){
          println(name+ "  " + age)
        }
    

待續......

Scala學習筆記一之基礎語法，條件控制，循環控制，函數，數組，集合