Scala的集合

1.集合基礎(chǔ)概念

? (1)集合的相關(guān)介紹

? ? Scala的集合有三大類：序列（seq）、集合（set）、映射（map）所有的集合都擴(kuò)展自Iterable 特質(zhì)，在Scala中集合有可變和不可變兩種類型，可變集合可以在適當(dāng)?shù)牡胤奖桓禄蛘邤U(kuò)展，這意味著可以修改、添加、移除一個(gè)集合的元素，而不可變集合類則永遠(yuǎn)不會(huì)改變，但是仍然可以模擬添加、移除、或者更新操作，但是這些操作下都會(huì)返回一個(gè)新的集合。immutable 類型的集合 初始化后就不能改變了（注意與 val 修飾的變量進(jìn)行區(qū)別），val 和 var：表明定義的變量（引用）是否能被修改而指向其他內(nèi)容。
? ? 表明的是內(nèi)存中開(kāi)辟出來(lái)的這塊空間里的內(nèi)容能否被修改，如果針 對(duì) immutable 變量進(jìn)行修改，其實(shí)是開(kāi)辟了一塊新的內(nèi)存空間，產(chǎn)生了一個(gè)新的變量，而 原來(lái)的變量依然沒(méi)有改變

? (2)scala的集合類的結(jié)構(gòu)

? ?所有關(guān)于集合的類都在：scala.collection包中。

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

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

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

2.集合的相關(guān)使用

（1）序列-list

 不可變序列：
 object Test01 {
  def main(args: Array[String]): Unit = {
   //1.創(chuàng)建一個(gè)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集合中的最后一個(gè)元素
    println(list01.last)    //4
    //6.集合元素反轉(zhuǎn)
    println(list01.reverse) //4 3 2 1
    //7.丟棄集合中的前n個(gè)元素
    list01 drop 2
    //8.獲取集合中的前N個(gè)元素
    var list02=list01.take(3)
    //9.將集合進(jìn)行分裂,返回一個(gè)tuple 第一個(gè)元素只有2個(gè)元素的list,第二個(gè)是集合中的剩下的所有元素
    val tuple: (List[Int], List[Int]) = list01.splitAt(2)
    //10.將兩個(gè)集合壓縮成一個(gè)
    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.集合，轉(zhuǎn)換為字符串
    println(list01.mkString(","))

    //12.集合轉(zhuǎn)化為數(shù)組
    val arr=list01.toArray
  }
}

可變序列：
    object Test01 {
  def main(args: Array[String]): Unit = {
   //1.創(chuàng)建一個(gè)list集合
    val list01=ListBuffer(1,2,3,4)
    //向可變序列中追加元素 (不會(huì)生成新序列)
    list01+=1
    list01.append(0)
    //兩個(gè)集合合并，會(huì)生出新的序列
    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 = {
//創(chuàng)建一個(gè)不可變的set
var set01 =new mutable.HashSet[Int]()
val set02=set01+5 //生成一個(gè)新的set
val set03=set01++set02 //兩個(gè)集合之間的合并
}
}

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

//4.set的常用場(chǎng)景
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，一個(gè)是 immutable 包下的 Map，該 Map 中的內(nèi)容不可變； 另一個(gè)是 mutable 包下的 Map，該 Map 中的內(nèi)容可變

不可變map
object Test01 {
def main(args: Array[String]): Unit = {
//1.創(chuàng)建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中相應(yīng)元素的值，根據(jù)key找value
println(base_info.getOrElse("age",18)) //表示根據(jù)key找value，如果沒(méi)有使用默認(rèn)值
base_info("age")=25 //注意這句代碼是錯(cuò)誤的，因?yàn)閯?chuàng)建的不可變map，不能修改其中的值。

//3.遍歷map
for(kv<-base_info){
  println(kv._1,kv._2)
}
//使用map自帶的foreach函數(shù)遍歷
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.創(chuàng)建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")
//判斷是否有這個(gè)元素
base_info.contains("name")  //根據(jù)key判斷是否有這個(gè)元素

}
}

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

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

報(bào)出錯(cuò)誤：
![](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.創(chuàng)建map
val base_info = collection.mutable.
HashMap("name" -> "zs", "age" -> 18, "address" -> "beijign")
//傳遞不存在的key
println(base_info.get("hobby")) //返回none并不是報(bào)錯(cuò)
}
}

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

### （5）元組-Tuple
元組的創(chuàng)建：

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

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

}
}

元組的轉(zhuǎn)化：

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

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

object Test01 {
def main(args: Array[String]): Unit = {
//定義一個(gè)數(shù)組
val arr=Array("zzy,zs,ww,zl","zy,jj,ww,cl","zzy,jj,ww","jj,cl,ww")
//1.第一步，將數(shù)組中的每一個(gè)元素按，切分
//((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.將數(shù)組元素為元組的，數(shù)組，壓平成一個(gè)全是字符串的數(shù)組
//zzy zs ww zl zy jj ww cl zzy jj ww jj cl ww
val word: Array[String] = words.flatten

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

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

//5.對(duì)每個(gè)分組的元素進(jìn)行聚合
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))
  }
}