1. 陣列相關操作

• 如果需要一個長度不變的陣列，可以用Scala中的Array，提供初始值時不要使用new

val nums = new Array[Int](10) //10個整數的陣列，所有元素初始化為0
val s = Array("hello","world") //提供初始值時，不需要使用new

• 對於長度按需要變化的陣列，可以使用Scala中的ArrayBuffer

import scala.collection.mutable.ArrayBuffer
val a = new ArrayBuffer[Int]      //一個空的緩衝陣列，準備存放整數
b += 1                            //用+=在緩衝陣列尾部新增元素
 

b += (1,2,3)                      //在尾端新增多個元素，用括號括起來
b ++= Array(8,13,21)              //用++=操作符追加任何集合
b.trimEnd(5)                      //移除最後5個元素
b.insert(2,6)                     //在下標為2元素之前插入6，這種操作並不高效
b.remove(2)                       //移除下標為2的元素
b.remove(2,3)                     //移除下標為2的元素以及他後面的2個元素，一共3個元素
 

• 有時需要構建一個Array，但不知道最終需要裝多少元素，可以先構建一個緩衝陣列，然後呼叫b.toArray。呼叫a.toBuffer可以將一個數組a轉化成一個緩衝陣列
• 遍歷陣列和緩衝陣列，可以用相同的程式碼處理這兩種資料結構

 for (i <- 0 until a.length){
    ...
 }

如果想要每兩個元素一跳

 for (i <- 0 until (a.length，2)){
    ...
 }

如果要從陣列的尾端開始

 for (i <- (0 until a.length).reverse){
    ...
 }

• 陣列轉換，從一個數組或緩衝陣列出發，以某種方式對它進行轉換是很簡單的。這些轉換動作不會修改原始陣列，而是產生一個全新的陣列。

 val a = Array(2,3,5,7,11)
 val result = for (i <- a) yield 2 * i //result是Array(4,6,10,14,22)

for (...) yield迴圈建立了一個型別與原始集合相同的新集合。從陣列出發，得到的是另一個數組，從緩衝陣列出發，得到的是另一個緩衝陣列
- 常用演算法
sum方法,元素型別必須是數值型別

Array(1,7,2,9).sum  //ArrayBuffer同樣適用

max和min方法：輸出陣列或緩衝陣列中最大和最小的元素,元素必須支援比較操作
sorted方法：將陣列或緩衝陣列排序並返回經過排序的陣列或緩衝陣列，不會修改原始版本。sortWith方法，可以提供比較函式

val b = ArrayBuffer(1,7,2,9)
val bSorted = b.sorted        //bSorted是ArrayBuffer(1,2,7,9)
val bDec = b.sortWith(_ > _)  //ArrayBuffer(9,7,3,1)

• 顯示陣列和緩衝陣列的內容，可以用mkString方法，它允許你指定元素之間的分隔符

val a = Array(1,2,7,9)
a.mkString(" and ") //"1 and 2 and 7 and 9"

• 多維陣列，通過陣列的陣列來實現，Double的二維陣列型別為Array[Array[Double]],構造這樣一個數組可以用ofDim方法

val matrix = Array.ofDim[Double](3,4) //3行，4列

2. 對映與元組

• 對映是鍵/值 對偶 的集合，對偶是一個n = 2的元組
• 構造對映
  不可變的Map[String,Int]

val scores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
val scores = Map(("Alice" , 10) , ("Bob" , 3) , ("Cindy" , 8))

可變對映

val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)

• 用()來查詢某個鍵對映的值

val bobsScore = scores("Bob")

如果對映並不包含請求中是用的鍵，則會丟擲異常

• 檢查對映中是否有某個指定的鍵，可以用contains方法
• 更新對映中的值。在可變對映中，你可以更新某個對映的值，或者新增一個新的對映關係

scores("Bob") = 10                   //更新鍵"Bob"對應的值，假設scores是可變的
scores("Fred") = 7                   //增加新的鍵/值對偶到scores
scores += (("Bob", 10) , ("Fred",7)) //增加多個關係用+=操作符
scores -= "Alice"                    //移除某個鍵和對應的值用-=操作符

對於不可變對映

val newScores = scores + (("Bob",10) , ("Fred",1)) //更新Bob，增加Fred
scores = scores - "Alice"                          //移除某個鍵

• 迭代對映
  遍歷對映中所有的鍵值對偶

for ((k,v) <- 對映) {
    處理k和v
}

訪問鍵或值

scores.keySet   //一個類似Set("Bob" , "Alice")的集
scores.values   

反轉一個對映

for ((k,v) <- 對映) yield (v,k)

• 元組(tuple)
  元組的值是通過將單個的值包含在圓括號中構成的，例如：

val t = (1,3.14,"Fred")  //型別為Tuple(Int,Double,java.lang.String)

用_1,_2,_3訪問其組元，元組的個組元從1開始

• 元組可以用於函式需要返回不止一個值的情況
• zip方法將多個值綁在一起

val symbols = Array("<","-",">")
val counts =Array(2,10,1)
val pair = symbols.zip(counts)  //輸出Array(("<",2),("-",10),(">",2))