Scala数据结构
一、数组(Array)
数组集合特点:元素具有相同的类型
声明一个整形数组:
scala> val intValueArr=new Array[Int](3)
intValueArr: Array[Int] = Array(0, 0, 0)
scala> intValueArr(0)=12
scala> intValueArr(1)=45
scala> intValueArr(2)=33
声明一个字符串数组:
scala> val myStrArr=new Array[String](3)
myStrArr: Array[String] = Array(null, null, null)
scala> myStrArr(0)="BigData"
scala> myStrArr(1)="Hadoop"
scala> myStrArr(2)="Spark"
scala> for(i <-0 to 2)println(myStrArr(i))
BigData
Hadoop
Spark
多维数组的创建:调用Array的ofDim方法
scala> val myMatrix = Array.ofDim[Int](3,4)
myMatrix: Array[Array[Int]] = Array(Array(0, 0, 0, 0), Array(0, 0, 0, 0), Array(0, 0, 0, 0))
scala> val myCube= Array.ofDim[String](3,2,4)
myCube: Array[Array[Array[String]]] = Array(Array(Array(null, null, null, null), Array(null, null, null, null)), Array(Array(null, null, null, null), Array(null, null, null, null)), Arr
ay(Array(null, null, null, null), Array(null, null, null, null)))
二、元组(Tuple)
需要返回多个类型不同的对象时可以使用元组
scala> val tuple=("BigData",2015,45,0)
tuple: (String, Int, Int, Int) = (BigData,2015,45,0)
scala> println(tuple._1)
BigData
scala> println(tuple._2)
2015
scala> println(tuple._3)
45
三、容器(Collection)
容器的三个包:
-
scala.collection
是封装了可变容器可不可变容器的超类(特质Trait),定义了一些可变容器和不可变的一些通用操作。 -
scala.collection.mutable
-
scala.collection.immutable
-
seq:按0,1,2索引
-
Map:按键索引
-
Set:无索引结构
四、序列(Sequence)
- LinearSeq:取头或取尾巴操作,列表、队列继承于它。
- IndexedSeq:有高效的随机存取操作,ArrayBuffer、Vector继承于它。
4.1列表(List):
具体的容器类,共享相同类型的不可变的对象序列;列表的值不可变,定义在scala.collection.immutable下,在声明时必须给它初始化。
var strList = List("BigData", "Hadoop", "Spark")
在列表中使用head、tail:
- head访问头部
scala> strList.head
res3: String = BigData
- tail访问尾部(除了第一个元素的所有元素)
scala> strList.tail
res4: List[String] = List(Hadoop, Spark)
构造列表的方法:
向已有列表前端增加元素
scala> val otherList="Apache"::strList
otherList: List[String] = List(Apache, BigData, Hadoop, Spark)
快速得到一个列表
scala> val intList=List(1,2,3)
intList: List[Int] = List(1, 2, 3)
scala> val intList=1::2::3::Nil//右结合,从右往左执行
intList: List[Int] = List(1, 2, 3)
4.2向量(Vector)
scala> val vec1=Vector(1,2)
vec1: scala.collection.immutable.Vector[Int] = Vector(1, 2)
scala> val vec2=3+:4+:vec1
vec2: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2)
scala> val vec3=vec2:+5
vec3: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2, 5)
scala> vec3(3)
res5: Int = 2
注意冒号一定要在向量哪一侧否侧会报错,如下:
scala> val vec4=vec3+:9
<console>:12: error: value +: is not a member of Int
val vec4=vec3+:9
^
调整位置后又可以了:
scala> val vec4=vec3:+9
vec4: scala.collection.immutable.Vector[Int] = Vector(3, 4, 1, 2, 5, 9)
4.3Range
Range是一种特殊的带索引的不可变数字等差序列。
起点 to 终点 by 步长
Range支持:
- 整形序列
- 字符型序列
- 单精度浮点型序列
Range案例1:
创建一个从1到5的数值序列包含区间终点5步长为1。
scala> val r=new Range(1,5,1)
r: scala.collection.immutable.Range = Range 1 until 5
scala> 1 to 5
res6: scala.collection.immutable.Range.Inclusive = Range 1 to 5
scala> 1.to(5)
res7: scala.collection.immutable.Range.Inclusive = Range 1 to 5
Range案例2:
创建一个从1到5的数字序列不包含区间终点,步长为1
scala> 1 until 5
res8: scala.collection.immutable.Range = Range 1 until 5
Range案例3:
创建一个从1到10的数字序列包含区间终点10,步长是2
scala> 1 to 10 by 2
res9: scala.collection.immutable.Range = inexact Range 1 to 10 by 2
Range案例4:
创建一个Float类型的数值序列从0.5到5.9,步长是0.3
scala> 0.5f to 5.9f by 0.3f
<console>:12: warning: method to in trait FractionalProxy is deprecated (since 2.12.6): u
se BigDecimal range instead
0.5f to 5.9f by 0.3f
^
res13: scala.collection.immutable.NumericRange[Float] = NumericRange 0.5 to 5.9 by 0.3
scala> res13.toBuffer
res14: scala.collection.mutable.Buffer[Float] = ArrayBuffer(0.5, 0.8, 1.1, 1.4000001, 1.7
, 2.0, 2.3000002, 2.6000001, 2.9, 3.2, 3.5, 3.8000002, 4.1000004, 4.4, 4.7000003, 5.0, 5.
3, 5.6000004)
我们可以看到出现报错,原因是Scala2.12.6以后的版本作出了调整这里使用toBuffer实现展示。
五、集合(Set)
- 可变集:scala.collection.mutable包
- 不可变集:scala.collection.immutable包
可变类型的变量
不可变集:
var mySet=Set("Hadoop","Spark")
//这种是不可变集合,从集合上来讲缺省情况下创建是不可变集
从集合上来讲缺省情况下创建是不可变集,Set("Hadoop","Spark")
是一个不可变集合对象;变量mySet它是一个可变类型的变量(可以去变更它的值)。开始可把一个不可变集赋值给一个可变的变量,后面可以再修改这个变量的变量值。
scala> mySet+="Scala"
scala> mySet
res16: scala.collection.immutable.Set[String] = Set(Hadoop, Spark, Scala)
mySet本身是一个可变的变量,开始指向一个不可变集;mySet+=“Scala"会在这个不可变集基础之上又增加一个元素Scala生成一个新的不可变集,然后把这个新的不可变集赋值给这个可变的变量mySet;相当于这个mySet前后指针变了一下,开始时指向Set(“Hadoop”,“Spark”),后面指向Set(“Hadoop”,” Spark", “Scala”)。
可变集:
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set
scala> val myMutableSet =Set("Database","BigData")
myMutableSet: scala.collection.mutable.Set[String] = Set(BigData, Database)
scala> myMutableSet +="Cloud Computing"
res17: myMutableSet.type = Set(BigData, Cloud Computing, Database)
前后两种情况,一种是可变量改变指向;另一种是将不可变量指向的数据集给改了。
六、映射(Map)
- 可变映射:scala.collection.mutable包
- 不可变映射:scala.collection.immutable包
默认情况下使用不可变映射,如果想用可变映射要明确导入scala.collection.mutable.Map包。
不可变映射:
scala> val university = Map("XMU"->"Xiamen University","THU"->"Tsinghua University","PKU"
->"Peking University")
university: scala.collection.immutable.Map[String,String] = Map(XMU -> Xiamen University,
THU -> Tsinghua University, PKU -> Peking University)
scala> println(university("XMU"))
Xiamen University
如果"XMU"
这键不存在则会报错,为了避免这种情况可以先调用contains
方法确定键是否存在。
scala> val xmu = if (university.contains("XMU")) university("XMU") else 0
xmu: Any = Xiamen University
scala> println(xmu)
Xiamen University
可变映射:
scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map
scala> val university2 = Map("XMU"->"Xiamen University","THU"->"Tsinghua University","PKU
"->"Peking University")
university2: scala.collection.mutable.Map[String,String] = Map(XMU -> Xiamen University,
THU -> Tsinghua University, PKU -> Peking University)
scala> university2("XMU")="Ximan University"//更新已有元素值
scala> university2("FZU")="Fuzhou University"//添加新元素
用加等于来添加新的元素
scala> university2 += ("TJU"->"Tianjin University")//添加一个新元素
res26: university2.type = Map(XMU -> Ximan University, THU -> Tsinghua University, FZU ->
Fuzhou University, TJU -> Tianjin University, PKU -> Peking University)
scala> university2 += ("SDU"->"Shandong University","WHU"->"Wuhan University")//同时添加两个新元素
res27: university2.type = Map(XMU -> Ximan University, SDU -> Shandong University, WHU ->
Wuhan University, THU -> Tsinghua University, FZU -> Fuzhou University, TJU -> Tianjin U
niversity, PKU -> Peking University)
七、迭代器(Iterator)
Scala Iterator(迭代器)不是一个集合,它是一种用于访问集合的方法。
迭代器 it 的两个基本操作是 next 和 hasNext。
调用 it.next() 会返回迭代器的下一个元素,并且更新迭代器的状态。
调用 it.hasNext() 用于检测集合中是否还有元素。
让迭代器 it 逐个返回所有元素最简单的方法是使用 while 循环:
object Iterator_test {
def main(args: Array[String]): Unit = {
val it = Iterator("Baidu", "Google", "Runoob", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}
Scala中的迭代器还有很多可以前往菜鸟教程学习:链接: https://www.runoob.com/scala/scala-iterators.html