1、元祖
映射是K/V對(duì)偶的集合，對(duì)偶是元組的最簡單形式，元組可以裝著多個(gè)不同類型的值。
1）、創(chuàng)建元祖

//創(chuàng)建元祖時(shí)，用小括號(hào)那個(gè)多個(gè)元素括起來，元素之間用逗號(hào)隔開，元素的類型可以不一樣，元素個(gè)數(shù)也可以任意多個(gè)
scala> val tp = (1,3.3,"scala")
tp: (Int, Double, String) = (1,3.3,scala)

2）、獲取元祖的值

scala> tp._1
res37: Int = 1

scala> tp._2
res38: Double = 3.3

scala> tp._3
res39: String = scala

//使用下面這種方式更直觀
scala> val t , (a, b, c) = (2, 2.2, "scala")
t: (Int, Double, String) = (2,2.2,scala)
a: Int = 2
b: Double = 2.2
c: String = scala

scala> x
<console>:9: error: not found: value x
              x
              ^

scala> a
res43: Int = 2

scala> b
res44: Double = 2.2

scala> c
res45: String = scala

//對(duì)偶元祖加到map中
scala> val m = Map(1 -> "a", 2 -> "b")
m: scala.collection.mutable.Map[Int,String] = Map(2 -> b, 1 -> a)

scala> val t = (3,"c")
t: (Int, String) = (3,c)

scala> m += t
res40: m.type = Map(2 -> b, 1 -> a, 3 -> c)

scala> m
res41: scala.collection.mutable.Map[Int,String] = Map(2 -> b, 1 -> a, 3 -> c)

3）、將對(duì)偶集合轉(zhuǎn)換成映射

scala> val arr = Array((1,"a"),(2,"b"))
arr: Array[(Int, String)] = Array((1,a), (2,b))

scala> val t = arr.toMap
t: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b)

scala> t
res46: scala.collection.immutable.Map[Int,String] = Map(1 -> a, 2 -> b)

4）、拉鏈操作
使用zip命令可以將集合中對(duì)應(yīng)的多個(gè)值綁定在一起

scala> val arr1 = Array(1,2,3)
arr1: Array[Int] = Array(1, 2, 3)

scala> val arr2 = Array("a","b","c")
arr2: Array[String] = Array(a, b, c)

scala> var arr3 = arr2.zip(arr1)
arr3: Array[(String, Int)] = Array((a,1), (b,2), (c,3))

scala> arr3
res47: Array[(String, Int)] = Array((a,1), (b,2), (c,3))

//如果其中一個(gè)元素要多，那么省去最后多余的
//即：如果兩個(gè)數(shù)組的元素個(gè)數(shù)不一致，拉鏈操作后生成的數(shù)組的長度為較小的那個(gè)數(shù)組的元素個(gè)數(shù)
scala> val arr4 = Array("a","b","c","d")
arr4: Array[String] = Array(a, b, c, d)

scala> var arr5 = arr4.zip(arr1)
arr5: Array[(String, Int)] = Array((a,1), (b,2), (c,3))
//arr4中多余的"d"就給省去了
scala> arr5
res49: Array[(String, Int)] = Array((a,1), (b,2), (c,3))

2、集合
Scala的集合有三大類：序列Seq、集Set、映射Map，所有的集合都擴(kuò)展自Iterable特質(zhì)（trait）
在Scala中集合有可變（mutable）和不可變（immutable）兩種類型，immutable類型的集合初始化后就不能改變了（注意與val修飾的變量進(jìn)行區(qū)別）

1）、序列
可認(rèn)為java的List

//創(chuàng)建不可變集合
scala> val list = List(1,2,3,4)
list: List[Int] = List(1, 2, 3, 4)

//獲取序列中角標(biāo)為0的元素
scala> list(0)
res50: Int = 1

//由于集合是不可變的所以企圖修改其中的值是行不通的
scala> list(0) = 6
<console>:10: error: value update is not a member of List[Int]
              list(0) = 6

//向集合中添加元素生成新的集合
//將0插入到lst1的前面生成一個(gè)新的List
scala> val list2 = 0 :: list
list2: List[Int] = List(0, 1, 2, 3, 4)

scala> list2
res52: List[Int] = List(0, 1, 2, 3, 4)

scala> val list3 = list.::(0)
list3: List[Int] = List(0, 1, 2, 3, 4)

scala> val list4 = 0 +: list
list4: List[Int] = List(0, 1, 2, 3, 4)

scala> val list5 = list.+:(0)
list5: List[Int] = List(0, 1, 2, 3, 4)

//將5添加到list最后面
scala> val list6 = list :+ 5
list6: List[Int] = List(1, 2, 3, 4, 5)

//將兩個(gè)list合并生成一個(gè)新的list
scala> list
res57: List[Int] = List(1, 2, 3, 4)

scala> val lst = List(1,5,6,7)
lst: List[Int] = List(1, 5, 6, 7)

scala> val ls = list ++ lst
ls: List[Int] = List(1, 2, 3, 4, 1, 5, 6, 7)

//將lst插入到list前生成一個(gè)新的list
scala> val ls2 = lst ++: list
ls2: List[Int] = List(1, 5, 6, 7, 1, 2, 3, 4)

下面是可變序列

//導(dǎo)入可變集合的所有包
scala> import scala.collection.mutable._
import scala.collection.mutable._

//創(chuàng)建可變序列（list）
scala> val lst = ListBuffer[Int]()
lst: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

//直接賦值初始化
scala> val lst2 = ListBuffer(4,5,6,7)
lst2: scala.collection.mutable.ListBuffer[Int] = ListBuffer(4, 5, 6, 7)
//添加元素，以下有兩種方式添加元素。注意：沒有生成新的集合
scala> lst += 1
res58: lst.type = ListBuffer(1)

scala> lst += 2
res59: lst.type = ListBuffer(1, 2)

scala> lst.app
append        appendAll     apply         applyOrElse

scala> lst.append
append      appendAll

scala> lst.append(3,4)

scala> lst
res61: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

// 將lst2中元素追加到lst中，注意：沒有生成新的集合
scala> lst ++= lst2
res62: lst.type = ListBuffer(1, 2, 3, 4, 4, 5, 6, 7)

scala> lst
res63: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 4, 5, 6, 7)

//兩個(gè)集合合并，生成了新的集合
scala> val lst3 = lst ++ lst2
lst3: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4, 4, 5, 6, 7, 4, 5, 6, 7)

2）、Set
不可變Set

scala> import scala.collection.immutable._
import scala.collection.immutable._

scala> val s1 = new HashSet[Int]()
s1: scala.collection.immutable.HashSet[Int] = Set()

//將元素1和s1合并生成一個(gè)新的set，原有set不變
scala> s1 + 1
res64: scala.collection.immutable.HashSet[Int] = Set(1)

//發(fā)現(xiàn)原來的set中還是空
scala> s1
res65: scala.collection.immutable.HashSet[Int] = Set()

scala> res64
res66: scala.collection.immutable.HashSet[Int] = Set(1)

//創(chuàng)建set的時(shí)候直接初始化
//重復(fù)的元素會(huì)去掉
scala> val set1 = Set(1,2,3,3)
set1: scala.collection.immutable.Set[Int] = Set(1, 2, 3)

//兩個(gè)set相加，生成新的set，重復(fù)的元素會(huì)自動(dòng)去掉，且元素排序不是按加入的時(shí)候順序，這樣這是set的特性
scala> val set2 = set1 ++ Set(3,4,5)
set2: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

可變set

scala> import scala.collection.mutable._
import scala.collection.mutable._

scala> val set1 = Set(1,2,3,3)
set1: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

//兩種方式添加元素，不會(huì)生成新的set
scala> set1.add(4)
res69: Boolean = true

scala> set1 += 5
res70: set1.type = Set(1, 5, 2, 3, 4)

scala> set1
res71: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)

//刪除元素的兩種方式
scala> set1 -= 5
res72: set1.type = Set(1, 2, 3, 4)

scala> set1.remove(4)
res73: Boolean = true

scala> set1
res74: scala.collection.mutable.Set[Int] = Set(1, 2, 3)

3）、map
這里只演示可變map了，都是跟上面一樣，操作跟java集合操作類似（需要導(dǎo)入可變集合的包，上面已經(jīng)導(dǎo)入過）

//創(chuàng)建可變map
scala> val map = new HashMap[String,Int]
map: scala.collection.mutable.HashMap[String,Int] = Map()

//兩種方式添加元素，不會(huì)生成新的集合
scala> map("zs") = 88

scala> map("ls") = 87

scala> map
res81: scala.collection.mutable.HashMap[String,Int] = Map(zs -> 88, ls -> 87)

scala> map.put("ww",99)
res82: Option[Int] = None

scala> map
res83: scala.collection.mutable.HashMap[String,Int] = Map(ww -> 99, zs -> 88, ls -> 87)

//兩種方式移除元素，不會(huì)生成新的集合


scala> map -= "ww"
res84: map.type = Map(zs -> 88, ls -> 87)

scala> map.remove("zs")
res85: Option[Int] = Some(88)

scala> map
res86: scala.collection.mutable.HashMap[String,Int] = Map(ls -> 87)