Scala的集合

1.集合基礎概念

? (1)集合的相關介紹

? ? Scala的集合有三大類：序列（seq）、集合（set）、映射（map）所有的集合都擴展自Iterable 特質，在Scala中集合有可變和不可變兩種類型，可變集合可以在適當的地方被更新或者擴展，這意味著可以修改、添加、移除一個集合的元素，而不可變集合類則永遠不會改變，但是仍然可以模擬添加、移除、或者更新操作，但是這些操作下都會返回一個新的集合。immutable 類型的集合 初始化后就不能改變了（注意與 val 修飾的變量進行區別），val 和 var：表明定義的變量（引用）是否能被修改而指向其他內容。
? ? 表明的是內存中開辟出來的這塊空間里的內容能否被修改，如果針 對 immutable 變量進行修改，其實是開辟了一塊新的內存空間，產生了一個新的變量，而 原來的變量依然沒有改變

? (2)scala的集合類的結構

? ?所有關于集合的類都在：scala.collection包中。

? ?不可變集合：scala.collection.immutable中。

? ?可變集合：scala.collection.mutable中。

? ?而在默認的情況下Scala使用的是不可變的集合類。如果行使用可變對象必須：scala.collection.mutable.Set

2.集合的相關使用

（1）序列-list

 不可變序列：
 object Test01 {
  def main(args: Array[String]): Unit = {
   //1.創建一個list集合
    val list01=List(1,2,3,4)
    //2.判斷集合是否為空
    println(list01.isEmpty) //false
    //3.獲取集合中的頭元素
    println(list01.head)    //1
    //4.獲取集合中除了head的其他元素
    println(list01.tail)    // 2 3 4
    //5.獲取list集合中的最后一個元素
    println(list01.last)    //4
    //6.集合元素反轉
    println(list01.reverse) //4 3 2 1
    //7.丟棄集合中的前n個元素
    list01 drop 2
    //8.獲取集合中的前N個元素
    var list02=list01.take(3)
    //9.將集合進行分裂,返回一個tuple 第一個元素只有2個元素的list,第二個是集合中的剩下的所有元素
    val tuple: (List[Int], List[Int]) = list01.splitAt(2)
    //10.將兩個集合壓縮成一個
    var list03=List(1,2,3,4)
    val list04=List("1","2","3","4")
    val lss=list03 zip list04
    println(lss.toString()) //[(1,"1"),(2,"2"),(3,"3"),(4,"4")]

    //11.集合，轉換為字符串
    println(list01.mkString(","))

    //12.集合轉化為數組
    val arr=list01.toArray
  }
}

可變序列：
    object Test01 {
  def main(args: Array[String]): Unit = {
   //1.創建一個list集合
    val list01=ListBuffer(1,2,3,4)
    //向可變序列中追加元素 (不會生成新序列)
    list01+=1
    list01.append(0)
    //兩個集合合并，會生出新的序列
    val list02=ListBuffer(1,2,3,4)
    val list03=ListBuffer(1,2,3,4)
    val list04=list02++list03
  }
}```

### (2) set集合

不可變set
object Test01 {
def main(args: Array[String]): Unit = {
//創建一個不可變的set
var set01 =new mutable.HashSet[Int]()
val set02=set01+5 //生成一個新的set
val set03=set01++set02 //兩個集合之間的合并
}
}

可變的set：
object Test01 {
def main(args: Array[String]): Unit = {
//1.創建一個可變的set
val set01=new mutable.HashSet[Int]()
//2.添加元素時，不會生成新的set
set01+=1
set01.add(1)
set01.add(2)
//3.刪除一個元素
set01-=1
set01.remove(2)

//4.set的常用場景
val set02=Set(1,2,3,4)
val set03=Set(3,4,5,6)
//4.1 交集
val ints: Set[Int] = set02.intersect(set03)
//4.2 并集
val unin: Set[Int] = set02.union(set03)
//4.3差集
val diff: Set[Int]=set02.diff(set03)

}
}

### (3) map 映射
? ?     在 Scala 中，有兩種 Map，一個是 immutable 包下的 Map，該 Map 中的內容不可變； 另一個是 mutable 包下的 Map，該 Map 中的內容可變

不可變map
object Test01 {
def main(args: Array[String]): Unit = {
//1.創建map
val base_info=Map("name"->"zs","age"->18,"address"->"beijign")
val extr0info=Map(("hobby","basketball"),("tall",180),("work","computer"))

//2.獲取合修改map中的值
println(base_info.get("name")) //獲取map中相應元素的值，根據key找value
println(base_info.getOrElse("age",18)) //表示根據key找value，如果沒有使用默認值
base_info("age")=25 //注意這句代碼是錯誤的，因為創建的不可變map，不能修改其中的值。

//3.遍歷map
for(kv<-base_info){
  println(kv._1,kv._2)
}
//使用map自帶的foreach函數遍歷
base_info.foreach(kv=> println(kv._1,kv._2))

}
}

不可變map修改值異常：
![](https://s1.51cto.com/images/blog/201812/29/97eeade2cc6186a2fd826ab20fef264b.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)

可變map操作：
object Test01 {
def main(args: Array[String]): Unit = {
//1.創建map
val base_info=collection.mutable.
HashMap("name"->"zs","age"->18,"address"->"beijign")

//添加元素
base_info.put("hobby","basketball")
//添加map
val extra_info=collection.mutable.
  HashMap("name"->"zs","age"->18,"address"->"beijign")
val new_map=base_info++extra_info

//獲取元素的值
val name: Option[Any] = base_info.get("name")
//判斷是否有這個元素
base_info.contains("name")  //根據key判斷是否有這個元素

}
}

(4)Option, None, Some 類型介紹
?? None、Some 是 Option 的子類，它主要解決值為 null 的問題，在 java 語言中， 對于定義好的 HashMap，如果 get 方法中傳入的鍵不存在，方法會返回 null，在編寫代碼的 時候對于 null 的這種情況通常需要特殊處理，然而在實際中經常會忘記，因此它很容易引起 NullPointerException 異常。在 Scala 語言中通過 Option、None、Some 這三個類來避免這樣 的問題，這樣做有幾個好處，首先是代碼可讀性更強，當看到 Option 時，我們自然而然就 知道它的值是可選的，然后變量是 Option，比如 Option[String]的時候，直接使用 String 的話， 編譯直接通不過。
例：

object Test01 {
def main(args: Array[String]): Unit = {
//1.創建map
val base_info = collection.mutable.
HashMap("name" -> "zs", "age" -> 18, "address" -> "beijign")
//傳遞不存在的key
println(base_info("hobby"))
}
}

報出錯誤：
![](https://s1.51cto.com/images/blog/201812/29/28808585e5d883f4af2648bb8006a6da.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)

object Test01 {
def main(args: Array[String]): Unit = {
//1.創建map
val base_info = collection.mutable.
HashMap("name" -> "zs", "age" -> 18, "address" -> "beijign")
//傳遞不存在的key
println(base_info.get("hobby")) //返回none并不是報錯
}
}

**總結**：Option有兩個子類別，Some和None。當程序回傳Some的時候，代表這個函式成功地給了你一個String，而你可以透過get()函數拿到那個String，如果程序返回的是None，則代表沒有字符串可以給你。在Scala里Option[T]實際上是一個容器，就像數組或是List一樣，你可以把他看成是一個可能有零到一個元素的List。當你的Option里面有東西的時候，這個List的長度是1（也就是 Some），而當你的Option里沒有東西的時候，它的長度是0（也就是 None）。

### （5）元組-Tuple
元組的創建：

object Test01 {
def main(args: Array[String]): Unit = {
//創建tuple
val tuple01=(1,2,3)
val (name,age,id)=("zs",18,1001) //這種方式是給tuple中的每一個元素起名字

//val (name,age,id)=("zs",18,1001)方式的實際應用
def getMaxandMin(arr:Array[Int]) ={
  (arr.max,arr.min)
}
val (max,min)=getMaxandMin(Array(1,2,3,4)) //可以一次性獲取最大值，最小值

}
}

元組的轉化：

object Test01 {
def main(args: Array[String]): Unit = {
//創建一個全部是元組的數組
val arr=Array((1,"zs"),(2,"ls"),(3,"ww"))
val map = arr.toMap
map.foreach(e=>println(s"${e._1}:${e._2}"))
}
}

### （6）集合的綜合使用：
編寫wordcount程序：
方法一：

object Test01 {
def main(args: Array[String]): Unit = {
//定義一個數組
val arr=Array("zzy,zs,ww,zl","zy,jj,ww,cl","zzy,jj,ww","jj,cl,ww")
//1.第一步，將數組中的每一個元素按，切分
//((zzy,zs,ww,zl),(zy,jj,ww,cl),(zzy,jj,ww),(jj,cl,ww))
val words: Array[Array[String]] = arr.map(line=>line.split("\s+"))
//2.將數組元素為元組的，數組，壓平成一個全是字符串的數組
//zzy zs ww zl zy jj ww cl zzy jj ww jj cl ww
val word: Array[String] = words.flatten

//3.對數組元素進行分類輸出
//(zzy,1) (zs,1) (ww,1) (zl,1) ...
val tuples: Array[(String, Int)] = word.map(word=>(word,1))

//4.將元素進行分組
//map(ww,(1,1,1,1)),(zzy,(1,1))
val stringToTuples: Map[String, Array[(String, Int)]] = tuples.groupBy(x=>x._1)

//5.對每個分組的元素進行聚合
val wordcount: Map[String, Int] = stringToTuples.map(x=>(x._1,x._2.length))

}
}```
方法二：

object Test01 {
  def main(args: Array[String]): Unit = {
    val arr=Array("zzy,zs,ww,zl","zy,jj,ww,cl","zzy,jj,ww","jj,cl,ww")
    val words: Array[String] = arr.flatMap(line=>line.split("\\s+"))
    val word: Array[(String, Int)] = words.map(word=>(word,1))
    val stringToTuples: Map[String, Array[(String, Int)]] = word.groupBy((x=>x._1))
    stringToTuples.map(word=>(word._1,word._2.length))
  }
}