上接scala學習開始基本語法1
第五步：陣列的使用
在scala中，可以使用new來例項化物件，當你建立一個數組物件的時候，你可以使用數值或者是型別引數。但是在scala中，是使用[]來指明物件，java是使用<>。如下程式碼

package org.wq.learn
object day2 {
  def main(args: Array[String]): Unit = {
   val strs =  new Array[String](3)
   strs(0)="hello"
   strs(1)="!"
   strs(2)="scala~"
   strs.foreach(println)

  }
 }
 

從上面程式碼中可以看到，在Scala中使用[]來指明引數化物件，這裡使用了String，在使用陣列的時候，使用的是()。
在Scala中為什麼要使用（）來訪問陣列元素，因為對於陣列來說，它和其他資料型別並沒有什麼差別，當你在某個值後面添加了（），Scala把它翻譯為呼叫對應物件的apply方法。

package org.wq.learn
object day2 {
  def main(args: Array[String]): Unit = {
   val strs =  new Array[String](3)
   strs(0)="hello"
   strs(1)="!"
   strs(2
 
)="scala~"
   strs.foreach(println)
   var i=0
   for(i<- 0 to 2){
     println(strs(i))
   }
  }
 }

比如，strs(1),實際上是呼叫strs.apply(1)。這種方法步僅僅適用於陣列，Scala中的任何物件都可以。如果在後面寫()，就表示呼叫該物件的apply方法。如果是對某個物件賦值，如剛才的strs(2)=”scala~”就是呼叫apply方法，Scala會把賦值語句轉化成該物件的update，就是strs(2,”scala~”)。
所以，上面的程式碼可以寫成

package org.wq.learn
object day2 {
  def
 
 main(args: Array[String]): Unit = {
   val strs =  new Array[String](3)
   //賦值轉化成update方法
   strs.update(0,"hello")
   strs.update(1,"!")
   strs.update(2,"scala~")
   var i=0
   for(i<- 0 to 2){
     //()呼叫成apply方法
     println(strs.apply(i))
   }
  }
 }

從上面可以看出來，資料就是一個Scala中普通的資料型別，沒什麼好特別的。但是為了方便使用，提供了下面的初始化陣列的方法。

val v1s =  Array("hello","!","scala!")
val v2s=Array.apply("hello","!","scala!")

不用new ,直接使用Array。

第五步：使用Lists
Scala是一個面向函式的程式語言，面向函式的程式設計有一個特點，就是呼叫某個方法的時候，不應該有任何的副作用，引數一定，呼叫方法之後，只能得到返回值。這樣的好處是函式是獨立的，互相之間的關聯減少了，從而是函式的重用性和可靠性編好了。使用這個原則，就表明，變數設定成不可修改的，也避免了多執行緒訪問的互鎖問題。
前面說的陣列，他的元素是可以修改的。如果想使用不可修改的序列，請使用Lists，這點和java不同，java中的lists是可以修改的，我去。Scala中的Lists設計出來滿足函數語言程式設計的風格的。大款的使用方法：

val fruit = "apples" :: "oranges" :: "pears" :: Nil
    println(fruit.head)//頭元素
    println(fruit.last)//尾元素
    println(fruit.length)//長度
    println(fruit.reverse)//反轉
    println(fruit(1))//通過()訪問

定義Lists為：

val list1 = List(1,2,3)
val list2 = List()
println(list1(1))

第六步：元組的使用（Tuples）
Scala中還有一個非常重要的容易，Tuples，元組和Lists不同，Lists和陣列只能儲存同一種資料型別的值，但是元組可以儲存多種資料型別，所以Tuples在返回多個值的時候比較有用。定義了Tuples之後，就可以使用索引和._來訪問元素

val tuples = ("wangqi",26)
println(tuples._1)
println(tuples._2)

這裡注意的是，和lists和陣列不同，Tuples的索引是從1開始的。
Tuples的分量的實際資料型別決定Tuples的型別。比如，上圖的Tuples為 Tuples[String,Int]
第七步：使用Sets和Maps
Scala的目標是想然讓開發者同時使用面向物件和麵向函式的程式設計方式編寫程式，因此它提供的集合分成了2個大類，2個部分，可以修改的集合和不可以修改的集合。比如Array是可以修改的，Lists是不可以修改的。Scala中也提供了兩種Sets和Maps集合。
關於Sets，Scala中定義了基類，基類的型別為Trait的Set，類似java中的介面，但是Trait可以實現方法.。Set下面分開，有2個，一個是可變型別-Mutable.Set，一個是不可變型別Immutable.Set。看圖使用-xmind畫的，將就下，以後會改：

Set的基本使用：定義一個Set，新增一個元素，判斷元素是否包含”wang”字串

 var mysets=Set("wang","jia")
 mysets+="hello"
 println(mysets.contains("wang"))

Scala提供的另一個型別為Map，Scala也提供了2中，immutable和muttable

基本用法：定義，通過()訪問，key可以相同，但是訪問的是最後一個。

val maps= Map(1->"I",2->"am",3->"boy",4->"!")
println(maps(3))
結果為boy
val maps= Map(1->"I",3->"am",3->"boy",3->"!")
println(maps(3))
結果為!

第八步：函式式的程式設計風格
簡單來看，如果程式碼中有var，就是指令式程式設計，不是函式式。如果程式碼中只有val，那麼就很有可能是函數語言程式設計，所以以後scala程式設計中，不要使用var，全部使用val。看個簡單列子

def printStrs(args:Array[String]):Unit={
    var i =0
    while(i<args.length){
      println(args(i))
      i+=1
    }
  }
   val str = Array("hello","scala")
   printStrs(str)

這是java的寫法，指令程式設計
我們去除vars變數，寫成符合函式程式設計

def printStrs2(args:Array[String]):Unit={
    for(arg<-args){
      println(arg)
    }
  }
printStrs2(str)

還可以改成物件的foreach函式呼叫

def printStrs4(args:Array[String]):Unit={
    args.foreach(println)
  }

減少vars的使用，使程式碼簡潔了，減少錯誤發生。所以scala開發原則是能減少mutable變數，就不使用。避免副作用，上面的println也是副作用哈。
今天加班有點累，就到這裡吧……感謝引路蜂提供的教程……