Scala数据结构

---

Seq（序列）

序列（Sequence）: 元素可以按照特定的顺序访问的容器。序列中每个元素均带有一个从0开始计数的固定索引位置

序列分类：
LinearSeq（线性）序列具有高效的 head 和 tail 操作
IndexedSeq（索引）序列具有高效的随机存储操作

索引序列——Array

数组：一种可变的、可索引的、元素具有相同类型或不同数据类型的数据集合。
Scala提供了参数化类型的通用数组类Array[T]，其中T可以是任意的Scala类型，可以通过显式指定类型或者通过隐式推断来实例化一个数组

1. 声明方法：

声明一个字符数组并对其元素赋值
val arr1 = ArrayChar
val arr2 = ArrayBufferChar
arr2.+=(‘d’)//向后追加d
arr2.+=:(‘e’)//向前追加e
arr2.append（’1’,’2’,’3’）

2. Array小结

(1)Array用于定义不可变数组，该数组一旦定义其元素值不能修改，ArrayBuffer用于定义可变数组
(2)Array的不可变性与val和var无关
(3)当Array在定义时省略new时，其后（）中为数组元素值，若不省略，其后（）中为数组元素个数
(4)当定义数组时，不指定数组类型，则数组默认为null
(5)可以不给出数组类型，Scala会自动根据提供的初始化数据来推断出数组的类型，当未给出初始值，默认为null，类型为Nothing，如果初始值是不同的基本数据类型，推断的类型为AnyVal
(6)定义ArrayBuffer时当使用new来实例化，如果使用不能通过数组名（索引值）=数组值方式赋值，可以使用.+=(元素值）向后追加或使用.+=:(元素值）向前追加的方式来添加元素

3. 数组遍历

方法一：
arr.foreach(s=>{println(s)}
或
arr.foreach(println)
方法二：
for(s <- arr){println(s)}

4. 常用属性和方法：

(1)可变数组添加元素——append（newele）
(2)可变数组插入元素——insert（index，newele）
(3)可变数组删除元素——remove（index[,num]）
(4)翻转数组——reverse
(5)数组元素排序：
	升序——sorted
	降序——sorted.reverse
(6)可变数组删除数组后面中num个元素——trimEnd(num)
(7)可变数组删除数组前面中num个元素——trimStart(num)
(8)将两个数组重新组合
	var a = Array.concat(arr1,arr2) 或使用 arr1++ar2
(9)初始化数组长度，且为所有元素赋相同的初值
	var a = Array.fill(5)(“hello”)
(10)不可变数组转换为可变数组——toBuffer

索引序列——Range

Range类：一种特殊的、带索引的不可变数字等差序列。其包含的值为从给定起点按一定步长增长(减小)到指定终点的所有数值
Range可以支持创建不同数据类型的数值序列，包括Int、Long、Float、Double、Char等

1. 定义方法

val rangename = Range（start，end，step）

2. 遍历数据：

rangename.foreach(println)

线性序列——List

列表（List）和（ListBuffer）
List是不可变的对象序列
ListBuffer则可以定义可变的对象序列
scala的List一旦被定义，其值就不能改变，因此声明List时必须初始化，而ListBuffer可以通过append方法追加元素

1. 定义不可变列表：

方法一：
val listname = List（元素列表）
方法二
val listname = List[数据类型]（元素列表）
方法三：
val list = 1 :: 2 :: 3 :: Nil
:: 用于将多个元素串起来
Nil 空列表对象Nil，借助Nil，可以将多个元素用操作符::串起来初始化一个列表
方法四：
val list = List.range(start,end)
方法五：
val list = List.fill(3)(“hello”)
方法六：转换为列表toList
val list = ‘string’.toList

2. 增加元素

(1)在List列表前增加元素——新元素 :: listname
(2)在ListBuffer增加元素
向后：
listname.+=(新元素）或
listname.append(新元素列表）
向前：listname.+=:(新元素）
(3)在ListBuffer删除元素——
listname. -=（删除的元素）
listname.remove(删除元素的索引）
(4)获取列表元素（可变与不可变）——apply（index）
(5)判断列表中是否包含某个元素值——contains（ele）
(6)获取列表的第一个元素——list.head
(7)获取列表的最后一个元素——list.last
(8)删除列表中第一个数据——list.tail

3. 列表遍历

(1)for （e <- listname）{println（e）}
(2)listname.foreach(println)
10. 列表的合并：
(1)list1++list2
(2)list1:::list2
(3)List.concat（list1，list2）

元组

元组是对多个不同类型对象的一种简单封装

1. 定义方法：

(1)val tpname = （元素列表）
(2)val tpname =new Tuple3(元素列表）

2. 注意：
   元组支持的最大元素个数为22个
3. 元素的访问：
   使用下划线“_”加上从1开始的索引值，来访问元组的元素

---

集合（Set）

集合是不包含重复元素的可迭代对象

1. 分类：

可变集合：scala.collection.mutable
不可变集合：scala.collection.immutable
缺省情况下创建的是不可变集合
默认创建的集合为HsahSet，是无序的

2. 不可变集合的定义：

val setname = Set[type](元素列表）

3. 可变集合的定义：

import scala.collection.mutable.Set
val setname = Set[type]（元素列表）

4. 元素添加

(1)可变集合元素的添加
setname += newele
setname.add(newele)
(2)可变和不可变集合通过连接实现集合元素添加
val setname = setname +（newele） //连接元素
val setname = set1++set2 //集合的连接

4. 元素删除

(1)可变集合元素的删除
setname - = deleteele
setname.remove(deleteele)
setname.clear
(2)不可变集合元素的删除
newSet = setname – deleteele
newSet = setname – （被删除元素列表）

5. SortedSet和LinkedHashSet

SortedSet的元素是有序的
LinkedHashSet按照插入顺序保存元素的

---

映射(Map)

映射(Map)：一系列键值对的容器。键是唯一的，但值不一定是唯一的。可以根据键来对值进行快速的检索。

1. 分类：

可变映射：scala.collection.mutable
不可变映射：scala.collection.immutable
缺省情况下创建的是不可变映射

2. 不可变映射定义：

val mapname = Map(键 -> 值,键 -> 值)
val mapname = Map((键，值),(键，值）)

3. 元素添加

(1)不可变映射元素的添加
newmap = mapname+((key，value),(key，value),……)
(2)不可变映射中单个元素的添加与修改
newmap= mapname+（(key,newvalue))
(3)不可变映射连接
map1 ++ map2

4. 删除元素

newmap = mapname – key1- key2

5. 可变映射的定义

import scala.collection.mutable.Map
val mapname = Mapkeytype,valuetypt

6. 查看值的方法：

mapname（key）

7. 添加元素

(1)可变映射中元素的添加
mapname +=（（newkey，newvalue）,……）
(2)可变映射中单个元素的添加与修改
mapname（key）=value
(3)从另一个映射中添加多个元素
mapname ++= othermap

8. 删除元素

(1)可变映射中元素的删除
mapname – =（（newkey，newvalue）,……）
(2)可变集合中单个元素的添加与修改
mapname（key）=value
(3)删除一个映射中指定的元素
mapname – –= List（key）

9. 获取映射中的键和值：

获取键：mapname.keys
获取值：mapname.values

10. 遍历映射中的元素：

(1)for((k,v)<- mapname) println(k,v)
(2)mapname.foreach{println}

11. 小结

SortedMap返回元素按照键有序的映射
LinkedHashMap可以按插入时的顺序返回元素
ListMap可以按插入时的相反顺序返回元素