一、概述

1，特點

)Scala同時支援不可變集合和可變集合

)兩個主要的包：

    不可變集合：scala.collection.immutable

    可變集合：  scala.collection.mutable

)Scala預設採用不可變集合，對於幾乎所有的集合類，Scala都同時提供了可變(mutable)和不可變(immutable)的版本

)Scala的集合有三大類：序列Seq、集Set、對映Map，所有的集合都擴充套件自Iterable特質，在Scala中集合有可變（mutable）和不可變（immutable）兩種型別。 

2，不可變集合繼承一覽圖

3，可變集合繼承一覽圖

二、陣列

1，可變和不可變:

　　Array ===> ArrayBuffer

2，定義不可變資料陣列方式

//定義陣列：方式一

val arr = new Array[Int]()

//定義陣列：方式二

val arr = Array(,,"scala") //呼叫apply方法

arr()= //賦值，索引1的值為8

//新增，生成一個新的陣列

arr.+:()

//刪除，刪除值為1的元素（並且只刪除第一個）

val array: Array[Any] = arr.drop()

//改，修改索引1的值為6

arr.update(,)

arr()= 

3，定義變長陣列

//定義變長陣列

val ints = new ArrayBuffer[Int]()
 

val ints = ArrayBuffer[Int](, , )

//新增，同一個陣列

ints.append()

//刪除，刪除索引為2之後的2個元素

ints.remove(,)

//改，同定長陣列

ints()=

ints.update(,)

4，定長陣列與變長陣列轉換

)arr1.toBuffer  //定長陣列轉可變陣列

)arr2.toArray  //可變陣列轉定長陣列

5，多維陣列

//定義 arr 是一個二維陣列:有三個元素[一維陣列]，每個一維陣列存放4個值

val arr = Array.ofDim[Double](,)

//賦值

arr()() = 11.11

6，Scala陣列與Java的List互轉

// Scala集合轉成Java集合

val arr = ArrayBuffer("", "", "")

import scala.collection.JavaConverters._  //隱式轉換

val javaList: util.List[String] = arr.asJava

println(javaList)    //[1, 2, 3]

//java的List轉成scala的ArrayBuffer

val arrList = new util.ArrayList[String]()

arrList.add("test")

//隱式轉換

import scala.collection.JavaConversions.asScalaBuffer

import scala.collection.mutable

val scalaArr: mutable.Buffer[String] = arrList

三、元組

1，簡介

　　元組也是可以理解為一個容器，可以存放各種相同或不同型別的資料。

　　說的簡單點，就是將多個無關的資料封裝為一個整體，稱為元組, 最大的特點靈活,對資料沒有過多的約束。 //需求-> 高效率

2，建立

//1. tuple 的型別是 Tuple3

//2. 根據元素個數不同，對應的型別是 Tuple1----Tuple22

//3. Tuple是一個整體，使用迭代器進行遍歷

//4. 訪問Tuple的元素的方式是 tuple._1 .... tuple._3

//5. 元組是scala推薦使用，在java沒有

val tuple = (, , "scala")

四、集合

1，定義:

　　Scala的List可以直接存放資料，就是一個object，預設情況下Scala的List是不可變的，List屬於序列Seq。

　　不可變、可變:List ===>ListBuffer

2，建立:

　　val ints:List[Int] = List(1,2,3) //建立

　　List預設採用不可變方式在immutable包下不用引包，List中可以放任何型別數據List[Any]，空集合可以直接使用Nil物件

3，List常用操作

val ints = List(,,,)

//新增

val ints1 = ints :+     //ints集合後面追加

val ints2 =  +: ints    //ints集合前面新增

val ints3 =  :: ints      //將1作為元素往ints中新增

val ints3 = ints1 :: ints //將ints1中的元素與ints中元素合併為一個集合，:::兩邊都是集合

//修改，會生成一個新的集合

val intsUpdate = ints .updated(,)

//刪除，擷取原集合指定索引以及後面的所有元素生成一個新的集合

val intsDrop = ints.drop() //List(4, 5)

4，ListBuffer常用操作

val buffer = ListBuffer(,,)

//新增

buffer.append()

//修改

buffer.update(,)

//刪除

buffer.remove()

println(buffer.mkString(","))  //6,1,10

五、Map

1，定義

　　Scala中的Map 和Java類似，也是一個散列表，它儲存的內容也是鍵值對(key-value)對映，Scala中不可變的Map是有序的，可變的Map是無序的。

　　不可變、可變:scala.collection.immutable.Map ===>scala.collection.mutable.Map

2，不可變immutable.Map

//建立

//方式一:底層為元組Tuple2型別，輸出順序與宣告順序一致

val map1 = Map("A" -> , "B" -> , "C" -> )

//方式二:對偶元組

val map2 = Map( ("A", ), ("B", ), ("C", ),("D", ) )

3，可變mutable.Map

//建立: 輸出順序與宣告順序不一致

val map1 = scala.collection.mutable.Map("A" -> , "B" -> , "C" -> )

//新增

//新增並建立一個新的map

val map2 = map1 + ("FFF"->)

//新增，追加到原有mao中

map1 += ("FFF"->)

//刪除指定key

map1 -= ("B","C")

//修改指定key的值,如果沒有改key就為新增

map1.update("A",)

4，Map取值

//key不存在拋異常NoSuchElementException

map(key)

//map.get(key)得到Option物件，要麼是Some要麼是None

map.get(key).get

//key存在返回值，不存在返回預設值

map.getOrElse(key,default)

六、Set

1，可變不可變

　　immutable.Set ===>mutable.Set

2，可變set集合操作

//建立可變set集合

val mutableSet = mutable.Set(,,)

//新增元素的兩種方式

mutableSet.add()

mutableSet +=

//刪除元素的兩種方式

mutableSet -=

mutableSet.remove()