陣列
不可變陣列：

object ArrayApp extends App {
  val a = new Array[String](5)

  println(a.length)

  a(1) = "hello"
  foreachList(a)
  println()
  val b = Array("hadoop","spark","hive")
  foreachList(b)
  val c = Array(1,2,3,4,5,6,7,8)
  println("max="+c.max+
          " min="+c.min+
          " sum="+c.sum)
  println(c.mkString(" "))
  println(c.mkString("<"," ",">"))
  
  def foreachList(list: Array[String]): Unit ={
    for (i <- list){
      print(i+ "  ")
    }
  }
}
 

可變陣列

val d = scala.collection.mutable.ArrayBuffer[Int]()

  d+=1
  d+=2
  d+=(3,4,5)//可以加多個
  d++=Array(6,7,8)//兩個+加一個數組
  d.insert(0,0)//指定位置插入
  d.remove(1)//移除索引資料
  d.trimEnd(2)//倒敘刪除
  println(d)
  for(i <- 0.until(d.length)){
    print(i+" ")
  }
  println()
  for(ele <-d){
    print(ele+" ")
  }
  println()
  for(i <- 0.until(d.length).reverse){//反序遍歷
    print(i+" ")
  }
 

list
NIL為不可變的list

object ListApp extends App {

  val list = List(1,2,3,4,5)
  println(list) //List(1, 2, 3, 4, 5)
  println(list.head)//1,第一個元素
  println(list.tail)//List(2, 3, 4, 5),除第一個外都是tail

  val list1 = 1::Nil //為定長的list
  println(list1)

  val list2 = scala.collection.mutable.ListBuffer[Int]()//可變list

  list2+=1
  list2+=(2,3,4,5)
  list2++=List(6,6,7)
  list2-=2
  list2--=List(5,6)
  list2.toArray    //轉成陣列
  list2.toList    //轉成定長list
  list2.isEmpty   //是否為空
  list2.head      //頭元素
}

 //遞迴求和
  def sum(nums:Int*):Int={
    if(nums.length==0){
      0
    }else{
      nums.head + sum(nums.tail:_*)
    }
  }
  println(sum())
  println(sum(1,2,3,4))
 

set
可變set:scala.collection.mutable.Set
用法與list一樣 資料不重複

Map
Map(對映)是一種可迭代的鍵值對（key/value）結構。

所有的值都可以通過鍵來獲取。

Map 中的鍵都是唯一的。

Map 也叫雜湊表（Hash tables）。

Map 有兩種型別，可變與不可變，區別在於可變物件可以修改它，而不可變物件不可以。

預設情況下 Scala 使用不可變 Map。如果你需要使用可變集合，你需要顯式的引入 import scala.collection.mutable.Map 類

在 Scala 中 你可以同時使用可變與不可變 Map，不可變的直接使用 Map，可變的使用 mutable.Map。以下例項演示了不可變 Map 的應用：

// 空雜湊表，鍵為字串，值為整型
var A:Map[Char,Int] = Map()

// Map 鍵值對演示
val colors = Map(“red” -> “#FF0000”, “azure” -> “#F0FFFF”)
定義 Map 時，需要為鍵值對定義型別。如果需要新增 key-value 對，可以使用 + 號，如下所示：

A += (‘I’ -> 1)
A += (‘J’ -> 5)
A += (‘K’ -> 10)
A += (‘L’ -> 100)

object Test {
   def main(args: Array[String]) {
      val colors = Map("red" -> "#FF0000",
                       "azure" -> "#F0FFFF",
                       "peru" -> "#CD853F")

      val nums: Map[Int, Int] = Map()

      println( "colors 中的鍵為 : " + colors.keys )
      println( "colors 中的值為 : " + colors.values )
      println( "檢測 colors 是否為空 : " + colors.isEmpty )
      println( "檢測 nums 是否為空 : " + nums.isEmpty )
   }
}

keys 返回 Map 所有的鍵(key)
values 返回 Map 所有的值(value)
isEmpty 在 Map 為空時返回true
Map 合併
你可以使用 ++ 運算子或 Map.++() 方法來連線兩個 Map，Map 合併時會移除重複的 key。以下演示了兩個 Map 合併的例項:

object Test {
def main(args: Array[String]) {
val colors1 = Map(“red” -> “#FF0000”,
“azure” -> “#F0FFFF”,
“peru” -> “#CD853F”)
val colors2 = Map(“blue” -> “#0033FF”,
“yellow” -> “#FFFF00”,
“red” -> “#FF0000”)

  //  ++ 作為運算子
  var colors = colors1 ++ colors2
  println( "colors1 ++ colors2 : " + colors )

  //  ++ 作為方法
  colors = colors1.++(colors2)
  println( "colors1.++(colors2)) : " + colors )

}
}
執行以上程式碼，輸出結果為：

$ scalac Test.scala
$ scala Test
colors1 ++ colors2 : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)
colors1.++(colors2)) : Map(blue -> #0033FF, azure -> #F0FFFF, peru -> #CD853F, yellow -> #FFFF00, red -> #FF0000)
輸出 Map 的 keys 和 values
以下通過 foreach 迴圈輸出 Map 中的 keys 和 values：

  sites.keys.foreach{ i =>  
                       print( "Key = " + i )
                       println(" Value = " + sites(i) )}

}
}
檢視 Map 中是否存在指定的 Key
你可以使用 Map.contains 方法來檢視 Map 中是否存在指定的 Key。例項如下：

  if( sites.contains( "runoob" )){
       println("runoob 鍵存在，對應的值為 :"  + sites("runoob"))
  }else{
       println("runoob 鍵不存在")
  }
  if( sites.contains( "baidu" )){
       println("baidu 鍵存在，對應的值為 :"  + sites("baidu"))
  }else{
       println("baidu 鍵不存在")
  }
  if( sites.contains( "google" )){
       println("google 鍵存在，對應的值為 :"  + sites("google"))
  }else{
       println("google 鍵不存在")
  }

}
}
執行以上程式碼，輸出結果為：

$ scalac Test.scala
$ scala Test
runoob 鍵存在，對應的值為 :http://www.runoob.com
baidu 鍵存在，對應的值為 :http://www.baidu.com
google 鍵不存在

option&Some&None
Option型別代表任意的值，多用在集合操作中，它可以儲存任意型別的值，Option例項就是Some或者None物件例項，Some和None都是它的子類，他們都是final類，所以不能再有派生子類了
Option型別資料可以使用大部分的集合操作，可參考 Array（集合、序列）
Option資料存取其實是對Some物件的操作，看下面程式碼

val a = Array(10,20,"30","40")
val b = a.lastOption
println(b)      // Some(40)

a是一個集合，lastOption返回最後一個Option型別物件，lastOption的程式碼在TraversableLike.scala中

def lastOption: Option[A] = if (isEmpty) None else Some(last)
last方法



 def last: A = {
    var lst = head
    for (x <- this)
      lst = x
    lst
  }

head方法

  def head: A = {
    var result: () => A = () => throw new NoSuchElementException
    breakable {
      for (x <- this) {
        result = () => x
        break
      }
    }
    result()
  }

lastOption方法中將通過last取到的最後一個元素轉換為Some型別了，Some是Option的子類，所以返回結果是Option型別，那看看Some的程式碼

final case class Some[+A](x: A) extends Option[A] {
  def isEmpty = false
  def get = x
}

它實現了Option的get介面

def get: A
返回了傳入的引數 x，所以如果我們遇到Option型別物件，就可以通過它的get方法取得實際元素的值，如：

a.lastOption.get
除了Some型別外，如果集合中是空的，那麼操作返回None型別

case object None extends Option[Nothing] {
  def isEmpty = true
  def get = throw new NoSuchElementException("None.get")
}

比如Option中的map方法

  @inline final def map[B](f: A => B): Option[B] =
    if (isEmpty) None else Some(f(this.get))

也就是Option型別只會返回Some或None型別物件

Tuple

object MapTest {

  def main(args: Array[String]): Unit = {

    // 元組：Tuple,就是由（）包起來，和資料庫中一條記錄概念類似
    val t1 = (1,2)
    println(t1)
    println(t1._1) // 獲取tuple第一個元素
    println(t1._2) // 獲取tuple第二個元素

    val t2 = (1,"xiaoming","男",23,"高新區")
    println(t2)

    val a = List(1,2,3,4)
    // Tuple舉列：求List中a的長度，元素求和，元素的平方和
    // 設計成一個tuple(長度, 元素求和, 元素平方和)
    def sumSq(in:List[Int]):(Int,Int,Int) = in.foldLeft((0,0,0))((t,v) => (t._1+1,t._2+v,t._3+v*v))
    println(sumSq(a))

    // Map<K,V>
    val map1 = Map(1 -> "david", 3 -> "lisa")
    println(map1(1))  // 根據key獲取value
    println(map1(3))  // 根據key獲取value
    println(map1.contains(1)) // 判斷Map中包含某個元素
    println(map1.keys) // 獲取map中所有的key
    println(map1.values) // 獲取map中所有的values
    map1 + (2 -> "xiaoming") // 向map中新增一個元素
    map1 - 3    // 向map中刪除一個元素
    map1 ++ List(4 -> "xiaohuang",5 -> "xiaoliu")  // 向map新增多個元素
    map1 -- List(1,2)  // 向map刪除多個元素

  }