元組：Tuple,不同型別值的聚集。
將固定數量的專案組合在一起，以便它們可以作為一個整體傳遞。 與陣列或列表不同，元組可以容納不同型別的物件，但它們也是不可變的。
元祖的實際型別取決於它的分量的型別，比如下面的型別實際為 Tuple3[Int,String,String]
索引是從1開始的

object Tuple {
  def main(args: Array[String]): Unit = {
    val triple1 = (100, "Scala", "Spark")
    println(triple1._1)
    println(triple1._2)
    println(triple1._3)
    
 
//它們也可用於將資料值列表作為併發程式設計中的參與者之間的訊息傳遞。
    val triple2 = (4, 3, 2, 1)
    val sum = triple2._1 + triple2._2 + triple2._3 + triple2._4

    println("Sum of elements: " + sum)

    //元組的迭代
    val triple3 = (4, 3, 2, 1)

    triple3.productIterator.foreach { i => println("Value = " + i) }

    //元組轉換為字串：可以使用Tuple.toString()方法將元組的所有元素連線成字串
 

    val triple4 = new Tuple3(1, "hello", Console) //此處為顯式的使用

    println("Concatenated String: " + triple4.toString())
    //交換元素：可以使用Tuple.swap方法交換Tuple2中的元素
    val triple5 = new Tuple2("Scala", "hello")

    println("Swapped Tuple: " + triple5.swap)

  }
}

陣列：Array
    1.定長陣列
      val nums = new Array[Int](10) 長度為10 初始元素為0
    2.變長陣列
      ArrayBuffer
    3.常用演算法
      sum、max、sorted
    4.多維陣列
      多維陣列是通過陣列的陣列來實現的
    5.陣列轉換
      Scala中陣列轉換不會改變原來的陣列，只會產生一個新的陣列

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


    //ArrayBuffer
    val arraybuffer = ArrayBuffer[Int]()
    //新增元素
    arraybuffer += 1
    //用+=在尾部新增元素
    arraybuffer += (2,3,4,5)
    //新增多個元素,可以用++=新增任意集合
    arraybuffer ++= Array(6,7,8)
    //移除元素,可以從頭部或者尾部
    arraybuffer.trimStart(1)
    arraybuffer.trimEnd(3)
    //你也可以用從任意位置插入或者溢位元素，這種操作不高效
    arraybuffer.insert(2,11)//第一個引數為索引，第二個引數為插入值
    arraybuffer.remove(3,2)//第一個引數為索引，第二個引數為移除的個數
    //有時你需要構建一個Array，但是不知道需要裝多少元素，可以構建一個數組緩衝
    arraybuffer.toArray

    //陣列的遍歷
    val array = Array(1, 2, 3, 4, 5)
    //until是RichInt類的方法，返回所有小於上限的資料
    for (i <- 0 until array.length) {
      println(array(i))
    }
    //如果在迴圈體中不需要使用下標，我們可以直接訪問陣列元素
    for(elem <- array){
      println(elem)
    }

    arraybuffer.sum
    arraybuffer.max
    arraybuffer.sorted
    //多維陣列
    //這個Double的多維陣列型別為Array[Array[Double]],構造這個陣列使用ofDim方法
    val matrix1 = Array.ofDim[Double](3,4)//3行，4列
    //訪問元素
    //matrix1(row)(column)
    //不規則的陣列，每一行長度不相同
    val  matrix2=new Array[Array[Int]](10)
    for(i <- 0 until matrix2.length){
      matrix2(i) = new Array[Int](i+1)
    }

    //陣列的轉換
    //yield
    val a = Array(2,3,5,6)
    val result = for(elem <- a) yield  2 * elem
    //如果不滿足，可以通過守衛
    val result1 = for(elem <- a if elem % 2==0) yield  2 * elem
  }
}

程式設計師名言：“如果只能有一種資料結構，那就用雜湊表吧”
對映：Map(k,v)
    1.構造對映 mutable.Map[String ,Int];immutable.Map[String ,Int]
    2.獲取及更新對映值
    3.迭代對映  for((k,v) -> 對映) 處理k,v
    4.已排序對映

object MapOps {
  def main(args: Array[String]): Unit = {
    var scores1=Map("john" -> 10,"Alice" -> 20,"Bob" -> 30)
    //上述程式碼構造了一個不可變對映Map[String,Int],其值不能被改變,因為Map預設呼叫的是immutable包下的，原始碼為：val Map = immutable.Map
    //可變對映
    val scores2=scala.collection.mutable.Map("john" -> 10,"Alice" -> 20,"Bob" -> 30)
    //空對映，需要選定型別
    val scores3=new scala.collection.mutable.HashMap[String ,Int]

    //獲取對映中的值：可以根據鍵獲取值
    val johnScore=scores1("john")//類似Java中的scores.get("john")
    //檢查對映中是否包含某個值
    val bobScore = if(scores1.contains("Bob")) scores1("Bob") else 0
    //快捷寫法
    val aliceScore = scores1.getOrElse("Alice",0)
    //更新對映中的值，需要在可變對映中
    scores2("john")=80
    scores2 += ("Boole" -> 50,"LiLei" -> 45)
    //雖然不可變對映顧名思義不可變，但是你可以這樣
    val newScores=scores1 + ("HanMei" -> 99)
    //同理，你需要從不可變對映中移除某個值可以使用-去掉該鍵的對映
    scores1 = scores1 - "Alice"

    //迭代對映：你可以在Scala的for迴圈中使用模式匹配
    //如果只需要訪問鍵和值，你可以使用keySet和values，values方法返回的是一個Iterable，你可以在迴圈中使用這個Iterable
    scores1.keySet //一個類似Set的("john","Alice","Bob" )這樣的集
    for(i <- scores1.values) println(i)

    //已排序對映:預設情況下，Scala給的是雜湊表，需要順序的訪問所有的鍵，我們需要一個樹形對映

    val scores4 = scala.collection.immutable.SortedMap("john" -> 10,"Alice" -> 20,"Bob" -> 30)

    //如果要插入順序訪問所有鍵
    val scores5 = scala.collection.mutable.LinkedHashMap("john" -> 10,"Alice" -> 20,"Bob" -> 30)




  }
}