Scala 数组(Array),列表(List),元组(Tuple),集(Set),映射(Map),迭代器(Iterator)
2017-08-02 15:03
531 查看
1. 数组(Array)
数组是编程中经常用到的数据结构,一般包括定长数组和变长数组。本教程旨在快速掌握最基础和常用的知识,因此,只介绍定长数组。定长数组,就是长度不变的数组,在Scala中使用Array进行声明,如下:
val intValueArr = new Array[Int](3) //声明一个长度为3的整型数组,每个数组元素初始化为0 intValueArr(0) = 12 //给第1个数组元素赋值为12 intValueArr(1) = 45 //给第2个数组元素赋值为45 intValueArr(2) = 33 //给第3个数组元素赋值为33
需要注意的是,在Scala中,对数组元素的应用,是使用圆括号,而不是方括号,也就是使用intValueArr(0),而不是intValueArr[0],这个和Java是不同的。
下面我们再声明一个字符串数组,如下:
val myStrArr = new Array[String](3) //声明一个长度为3的字符串数组,每个数组元素初始化为null myStrArr(0) = "BigData" myStrArr(1) = "Hadoop" myStrArr(2) = "Spark" for (i <- 0 to 2) println(myStrArr(i))
实际上,Scala提供了更加简洁的数组声明和初始化方法,如下:
val intValueArr = Array(12,45,33) val myStrArr = Array("BigData","Hadoop","Spark")
从上面代码可以看出,都不需要给出数组类型,Scala会自动根据提供的初始化数据来推断出数组的类型。
2. 列表(List)
在后面的Spark学习中,我们会用到列表。下面我们首先声明一个列表:
val intList = List(1,2,3)
列表有头部和尾部的概念,可以使用
intList.head来获取上面定义的列表的头部,值是1,使用
intList.tail来获取上面定义的列表的尾部,值是
List(2,3),可以看出,头部是一个元素,而尾部则仍然是一个列表。
由于列表的头部是一个元素,所以,我们可以使用::操作,在列表的头部增加新的元素,得到一个新的列表,如下:
val intList = List(1,2,3) val intListOther = 0::intList
注意,上面操作执行后,
intList不会发生变化,依然是
List(1,2,3),
intListOther是一个新的列表
List(0,1,2,3)
::操作符是右结合的,因此,如果要构建一个列表
List(1,2,3),实际上也可以采用下面的方式:
val intList = 3::2::1::Nil
上面代码中,Nil表示空列表。
我们也可以使用:::操作符对不同的列表进行连接得到新的列表,比如:
val intList1 = List(1,2) val intList2 = List(3,4) val intList3 = intList1:::intList2
注意,执行上面操作后,
intList1和
intList2依然存在,
intList3是一个全新的列表。
实际上,Scala还为列表提供了一些常用的方法,比如,如果要实现求和,可以直接调用
sum方法,如下:
intList.sum
3. 元组(Tuple)
元组是不同类型的值的聚集。元组和列表不同,列表中各个元素必须是相同类型,而元组可以包含不同类型的元素。下面我们声明一个名称为tuple的元组(为了看到声明后的效果,我们这次在Scala解释器中输入代码并执行):
scala> val tuple = ("BigData",2015,45.0) tuple: (String, Int, Double) = (BigData,2015,45.0) //这行是Scala解释器返回的执行结果 scala> println(tuple._1) BigData scala> println(tuple._2) 2015 scala> println(tuple._3) 45.0
从上述代码在Scala解释器中的执行效果可以看出,我们声明一个元组是很简单的,只需要用圆括号把多个元组的元素包围起来就可以了。
当需要访问元组中的某个元素的值时,可以通过类似
tuple._1、tuple._2、tuple._3这种方式就可以实现。
4. 集(Set)
集(set)是不重复元素的集合。列表中的元素是按照插入的先后顺序来组织的,但是,”集”中的元素并不会记录元素的插入顺序,而是以“哈希”方法对元素的值进行组织,所以,它允许你快速地找到某个元素。集包括可变集和不可变集,缺省情况下创建的是不可变集,通常我们使用不可变集。
下面我们用默认方式创建一个不可变集,如下(在Scala解释器中执行):
scala> var mySet = Set("Hadoop","Spark") mySet: scala.collection.immutable.Set[String] = Set(Hadoop, Spark) scala> mySet += "Scala" //向mySet中增加新的元素 scala> println(mySet.contains("Scala")) true
上面声明时,如果使用
val,mySet += "Scala"执行时会报错,所以需要声明为
var。
如果要声明一个可变集,则需要引入
scala.collection.mutable.Set包,具体如下(在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" res0: myMutableSet.type = Set(BigData, Cloud Computing, Database) scala> println(myMutableSet) Set(BigData, Cloud Computing, Database)
上面代码中,我们声明myMutableSet为val变量(不是var变量),由于是可变集,因此,可以正确执行
myMutableSet += "Cloud Computing",不会报错。
注意:虽然可变集和不可变集都有添加或删除元素的操作,但是,二者有很大的区别。对不可变集进行操作,会产生一个新的集,原来的集并不会发生变化。 而对可变集进行操作,改变的是该集本身,
5. 映射(Map)
在Scala中,映射(Map)是一系列键值对的集合,也就是,建立了键和值之间的对应关系。在映射中,所有的值,都可以通过键来获取。映射包括可变和不可变两种,默认情况下创建的是不可变映射,如果需要创建可变映射,需要引入
scala.collection.mutable.Map包。
创建映射
下面我们创建一个不可变映射:
val university = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University")
如果要获取映射中的值,可以通过键来获取,如下:
println(university("XMU"))
上面代码通过
"XMU"这个键,可以获得值
Xiamen University。
如果要检查映射中是否包含某个值,可以使用contains方法,如下:
val xmu = if (university.contains("XMU")) university("XMU") else 0 println(xmu)
上面我们定义的是不可变映射,是无法更新映射中的元素的,也无法增加新的元素。如果要更新映射的元素,就需要定义一个可变的映射,如下:
import scala.collection.mutable.Map val university2 = Map("XMU" -> "Xiamen University", "THU" -> "Tsinghua University","PKU"->"Peking University") university2("XMU") = "Ximan University" //更新已有元素的值 university2("FZU") = "Fuzhou University" //添加新元素
也可以使用+=操作来添加新的元素,如下:
university2 + = ("TJU"->"Tianjin University") //添加一个新元素 university2 + = ("SDU"->"Shandong University","WHU"->"Wuhan University") //同时添加两个新元素
循环遍历映射
循环遍历映射,是经常需要用到的操作,基本格式是:
for ((k,v) <- 映射)语句块
下面给出一个实例:
for ((k,v) <- university) printf("Code is : %s and name is: %s\n",k,v)
上面代码执行结果如下:
Code is : XMU and name is: Xiamen University Code is : THU and name is: Tsinghua University Code is : PKU and name is: Peking University
或者,也可以只遍历映射中的k或者v。
比如说,我们只想把所有键打印出来:
for (k<-university.keys) println(k) XMU //打印出的结果 THU //打印出的结果 PKU //打印出的结果
再比如说,我们只想把所有值打印出来:
for (v<-university.values) println(v) Xiamen University //打印出的结果 Tsinghua University //打印出的结果 Peking University //打印出的结果
6. 迭代器(Iterator)
在Scala中,迭代器(Iterator)不是一个集合,但是,提供了访问集合的一种方法。当构建一个集合需要很大的开销时(比如把一个文件的所有行都读取内存),迭代器就可以发挥很好的作用。迭代器包含两个基本操作:
next和
hasNext。
next可以返回迭代器的下一个元素,
hasNext用于检测是否还有下一个元素。
有了这两个基本操作,我们就可以顺利地遍历迭代器中的所有元素了。
通常可以通过
while循环或者
for循环实现对迭代器的遍历。
while循环如下:
val iter = Iterator("Hadoop","Spark","Scala") while (iter.hasNext) { println(iter.next()) }
注意,上述操作执行结束后,迭代器会移动到末尾,就不能再使用了,如果继续执行一次
println(iter.next)就会报错。另外,上面代码中,使用
iter.next和
iter.next()都是可以的,但是,
hasNext后面不能加括号。
for循环如下:
val iter = Iterator("Hadoop","Spark","Scala") for (elem <- iter) { println(elem) }
相关文章推荐
- Scala基础学习之tuple(元组),Array(数组),Map(映射)
- Scala 变量-函数-循环-数组-List-元组-Set-Map 讲解
- 元组Tuple、数组Array、映射Map
- Map集合,List集合,Array数组,Iterator迭代,Collection集合,Set集合的多种遍历方式
- Scala之Array,List,Tuple,Set,Map
- scala 学习笔记(02) 元组Tuple、数组Array、Map、文件读写、网页抓取示例
- scala入门学习(4)列表List-集合Set-映射Map等
- Scala中的集合:Iterator、BitSet、Set、Map、Stack、Vector、List、Array
- python3基础: 元组tuple、 列表list、 字典dict、集合set。 迭代器、生成器
- Scala学习笔记--Array和List和Tuple和Set和Map
- Java中容器[Collection(List,Set,Queue),Map],迭代器(Iterator)和比较器(Comparator)及列表排序
- NHibernate集合映射中的set, list, map, bag, array
- js中数据结构数组Array、映射Map、集合Set、对象、JSON
- Hibernate的集合映射(Set、List、Array、Map、Bag)
- Hibernate的Set,List,Map集合映射,数组映射
- 列表(list)、元组(tuple)、字典(dict)和集合(set)的主要区别
- python中的集合详解(列表List,元组Tuple,字典,set)
- python 列表list 元组tuple 字典dict 集合set 介绍
- NHibernate集合映射中的set, list, map, bag, array
- NHibernate集合映射中的set, list, map, bag, array