敏捷硬件开发语言Chisel与数字系统设计 课件 第14章 集合

14.集合一、Scala集合基本内容二、数组三、列表四、数组缓冲与列表缓冲五、元组六、映射七、集八、集合的常用方法ContentsTitle

2一、Scala集合基本内容

3Scala同时支持可变集合和不可变集合。两个主要的包：

不可变集合：scala.collection.immutable

可变集合：scala.collection.mutableScala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变(mutable)和不可变(immutable)的版本。一、Scala集合基本内容1.1基本介绍

4二、数组

5数组是结构最简单的集合，访问速度更快。Array是一个具体的类，定义在了scala包下，可以通过new来构造一个数组对象。数组元素的类型可以是任意的，但是所有元素的类型必须一致。数组对象必须是定长的。

二、数组2.1基本介绍

6scala>valintArray=newArray[Int](3)

intArray:Array[Int]=Array(0,0,0)

scala>intArray(0)=1

scala>intArray(1)=2

scala>intArray(2)=3

scala>intArray

res0:Array[Int]=Array(1,2,3)newArray[T](n)方式一：2.2数组的创建二、数组T指的是数组元素的类型，n指的是数组元素的个数

数组元素采用小括号()访问和赋值，同时索引从0开始

数组元素的类型为Int，数组元素的个数为3个

7方式二：

Array的伴生对象里还定义了一个apply工厂方法，可以在定义数组时直接赋值；类型指定可有可无，会自动推断，因此也可以按如下方式构造数组对象：2.2数组的创建二、数组scala>valcharArray=Array('a','b','c')

charArray:Array[Char]=Array(a,b,c)

8三、列表

9列表中所有元素的类型都相同。列表是不可变的，一旦被定义了就不能改变，其次列表具有递归的结构。List默认为不可变的集合，定义在scala.collection.immutable包里，同时List也在scala包下声明了。三、列表3.1基本介绍

10scala>valintList=List(1,1,10,-5)

intList:List[Int]=List(1,1,10,-5)

scala>intList(0)

res0:Int=1

scala>intList(3)

res1:Int=-5列表类名为List，这是一个抽象类，因此不能用new来构造列表对象。但是伴生对象里有一个apply工厂方法，接收若干个参数，生成列表。3.2列表创建三、列表列表元素采用小括号()访问，索引从0开始

113.3列表相关操作三、列表操作符作用:+向列表的尾部添加元素或列表+：向列表的头部添加元素或列表::向列表的头部添加元素或列表:::用于拼接左、右两个列表向列表中增加元素,会返回新的列表/集合对象，所以需要一个新的列表对象来接收。在使用操作符增减元素时，一定要注意原列表与操作符的位置关系。

12三、列表3.3列表相关操作scala>vallist1=List(1,2,3)

list1:List[Int]=List(1,2,3)

scala>vallist2=list1:+4

list2:List[Int]=List(1,2,3,4)

scala>valtest=list1:+List(1,2)

test:List[Any]=List(1,2,3,List(1,2))

scala>vallist3=0+:list2

list3:List[Int]=List(0,1,2,3,4)

scala>vallist4=-2::-1::list3

list4:List[Int]=List(-2,-1,0,1,2,3,4)

scala>vallist5=list1:::list2

list5:List[Int]=List(1,2,3,1,2,3,4)

133.4列表子对象NilNil表示空列表，可以调用前面介绍过的几种添加元素的方法。除此之外，我们也可以利用Nil来创建列表。三、列表

scala>vallist=1::2::3::Nil

list:List[Int]=List(1,2,3)

14四、数组缓冲与列表缓冲

154.1基本介绍四、数组缓冲与列表缓冲操作符作用+=向缓冲的尾部添加元素+=：向缓冲的头部添加元素-=从缓冲的尾部开始删去第一个符合的元素ArrayBuffer/ListBuffer定义在了scala.collection.mutable包下。往尾部增加或删除元素时，元素数量可以不只一个，但是在头部添加时一次只能添加一个元素。可以通过方法“toArray”或“toList”把缓冲的数据构造成一个数组或列表对象。这是构造一个新的对象，原有缓冲仍然存在。newArrayBuffer/ListBuffer[Int]()

164.2代码举例四、数组缓冲与列表缓冲scala>importscala.collection.mutable.{ArrayBuffer,ListBuffer}

importscala.collection.mutable.{ArrayBuffer,ListBuffer}

scala>vala=newArrayBuffer[Int]()

a:scala.collection.mutable.ArrayBuffer[Int]=ArrayBuffer()

scala>a+=(1,2,3)

res1:a.type=ArrayBuffer(1,2,3)

scala>0+=:a

res2:a.type=ArrayBuffer(0,1,2,3)

scala>a-=2

res3:a.type=ArrayBuffer(0,1,3)

scala>valb=a.toArray

b:Array[Int]=Array(0,1,3)

17五、元组

18相同点：元组和列表一样，都是不可变的。不同点：列表包含的元素类型是相同的，元组可以包含不同类型的元素。定义位置不同，List定义在scala.collection.immutable包下，Tuplex定义在了scala包下

。五、元组元组列表5.1基本知识

19五、元组5.2元组的定义元组并不是一个类，而是一系列类：

Tuple1、Tuple2、Tuple3......

Tuple22。每个数字代表元组包含的元素数量，也就是说元组最多只能包含22个元素。newTupleX（元组元素）

方法一：valt=newTuple3("God",'A',10)

方法二：valt=("God",'A’,10)

205.2元组的索引五、元组不可遍历，也就无法通过下标来索引。只能通过“_1”、“_2”......这样来访问每个元素。索引元组的第一个元素，使用“_1”字段scala>valtuple=("God",'A',10)

tuple:(String,Char,Int)=(God,A,10)

scala>tuple._1

res0:String=God

scala>tuple._2

res1:Char=A

215.4元组的遍历五、元组元组数据的遍历和其他集合有些不同，需要先调用productIterator方法以获取其迭代器，然后对该迭代器进行遍历。左侧代码实现的是列表的遍历，右侧代码实现的是元组的遍历其功能为分别输出列表和元组中元素的值vala=List(1,2,3)

for(i<-a){

println(“i=”+i)

}valt1=(1,"a","b",true,2)

for(item<-t1.productIterator){

println("item="+item)

}

22六、映射

23映射是包含一系列“键-值”对的集合，键和值的类型可以是任意的，但是每个“键-值”对的类型必须一致。六、映射6.1映射的定义键->值映射并不是一个类，而是一个特质。所以无法用new构建映射对象，只能通过伴生对象里的apply工厂方法来构造映射类型的对象。表达式“object1->object2”实际就是一个对偶(二元组)，因此”键-值”对也可以写成对偶的形式。valmap1=Map(1->"+",2->"-",3->"*")valmap2=Map((1,"+"),(2,"-"),(3,"*"))

24方式一：

给apply方法提供一个键值作为参数，返回对应的值，若不存在则抛出异常。6.2映射的取值方式六、映射方式二：

使用map.getOrElse(key,“默认值”)取值，如果key存在，返回对应的值；如果key不存在，则返回提供的默认值。valmap=Map(1->"+",2->"-",3->"*")scala>println(map(3))

*scala>map.getOrElse(0,"defaultValue")

res2:String=defaultValue

25方式三：使用map.get(key).get。如果key存在，map.get(key)就会返回Some(值),然后Some(值).get就可以取出对应的值；如果key不存在，map.get(key)就会返回None。6.3映射的取值方式六、映射valmap=Map(1->"+",2->"-",3->"*")scala>map.get(0)

res0:Option[String]=None

scala>map.get(1)

res1:Option[String]=Some(+)

scala>map.get(1).get

res2:String=+

266.4映射的遍历六、映射for((k,v)<-map)//遍历所有的键和值，k就是键，v就是值

for(k<-map.keys)

//遍历所有的键

for(v<-map.values)//遍历所有的值

for(item<-map)//遍历所有的键值对，此时的item是元组

27七、集

28集和映射一样，也是一个特质，也只能通过apply工厂方法构建对象。集只能包含字面值不相同的同类型元素。对象的apply方法是测试是否包含传入的参数，返回true或false。Scala默认使用的是不可变集，其定义在scala.collection.immutable包下，声明在了scala包下，所以可以直接使用，不用导入。Set是无序的。七、集7.1基本介绍valset=Set(1,2,

3)

29scala>valset=Set(1,1,10,10,233)

set:scala.collection.immutable.Set[Int]=Set(1,10,233)

scala>set(100)

res0:Boolean=false

scala>set(233)

res1:Boolean=true7.2集的创建七、集测试是否包含传入的参数，若存在，返回true；若不存在，返回false。构建时传入了重复参数，但是从返回的结果上来看，重复的参数只保留了一个。

30八、集合的常用方法

31接收一个无副作用的函数作为入参，对调用该方法的集合的每个元素应用入参函数，并把所得结果全部打包在一个新的集合里返回。八、集合的常用方法8.1map方法scala>Array("apple","orange","pear").map(_+"s")

res2:Array[String]=Array(apples,oranges,pears)

scala>List(1,2,3).map(_*2)

res3:List[Int]=List(2,4,6)

32foreach方法与map方法类似，不过它的入参是一个有副作用的函数。8.2foreach方法八、集合的常用方法scala>varsum=0

varsum:Int=0

scala>Set(1,-2,234).foreach(sum+=_)

scala>sum

valres0:Int=233

33把两个可迭代的集合一一对应，构成若干个对偶。如果其中一个集合比另一个长，则忽略多余的元素。8.3zip方法八、集合的常用方法scala>List(1,2,3)zipArray('1','2','3')

res0:List[(Int,Char)]=List((1,1),(2,2),(3,3))

scala>List(1,2,3)zipSet(“God","OK")