集合
1、数组(Array)
\quad \quad Scala中,数组有两种,定长数组和变长数组
1.1 定长数组
\quad \quad
定长数组指的是数组的长度是不允许改变的
语法
// 通过指定长度定义数组,然后添加元素
val/var 变量名 = new Array[元素类型](数组长度)
变量名(所在位置)= 元素值
或
// 用元素直接初始化数组
val/var 变量名 = Array(元素1,元素2,.....)
- 数组的索引还是从零开始
- 数组元素赋值:变量名(所在位置)= 元素值
- 获取元素: 变量名(所在位置)
例子:
scala> val a=new Array[String](5)
a: Array[String] = Array(null, null, null, null, null)
scala> a(1)="hello"
scala> a
res27: Array[String] = Array(null, hello, null, null, null)
scala> a(1)
res28: String = hello
scala> val b = Array("hadoop","spark")
b: Array[String] = Array(hadoop, spark)
1.2 变长数组
\quad \quad 变长数组指的是数组的长度是可变的,可以往数组中添加、删除元素
定义变长数组
语法
- 创建空的ArrayBuffer变长数组
val/var 变量名=scala.collection.mutable.ArrayBuffer[元素类型]()
- 创建带有初始元素的ArrayBuffer变长数组
val/var 变量名=scala.collection.mutable.ArrayBuffer(元素1,元素2,....)
添加/修改/删除/插入元素
- 使用
+=
添加元素 - 使用
-=
删除元素 - 使用
++=
追加一个数组到变长数组 - 使用
insert
指定位置插入元素
// 定义变长数组
scala> val d=scala.collection.mutable.ArrayBuffer[Int]()
d: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()
// 添加元素
scala> d+=(3,4,5)
res36: d.type = ArrayBuffer(3, 4, 5)
// 追加一个数组
scala> d++=Array(6,7,8)
res38: d.type = ArrayBuffer(3, 4, 5, 6, 7, 8)
// 指定位置插入元素
scala> d.insert(0,2)
scala> d
res40: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(2, 3, 4, 5, 6, 7, 8)
// 删除元素
scala> d.remove(3)
res42: Int = 5
或
scala> d-=3
res46: d.type = ArrayBuffer(2, 4, 6, 7, 8)
1.3 可变数组转换为定长数组
scala> d.toArray
res43: Array[Int] = Array(2, 3, 4, 6, 7, 8)
1.4 遍历数组
\quad \quad 可以使用以下两种方式遍历数组
- 使用for表达式直接遍历数组中的元素
scala> val a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i<-a) println(i)
1
2
3
4
5
- 使用索引遍历数组中的元素
scala> val a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> for(i <- 0 to a.length-1){
| println(a(i))
| }
1
2
3
4
5
scala> for(i<-0 until a.length) println(a(i))
1
2
3
4
5
-
0 until n: 左闭右开,包含0,不包含n
-
0 to n: 左闭右闭,包含0,n
1.4 数组常用方法
\quad \quad scala中的数组封装了丰富的计算操作,将来在对数据处理的时候,不需要我们自己再重新实现。
以下为常用的几个算法:
- 求和——sum方法
- 求最大值——max方法
- 求最小值——min方法
- 排序——sorted方法
- 长度——length方法
- 转换成字符串——
scala> val a=Array(1,2,3,4,5)
a: Array[Int] = Array(1, 2, 3, 4, 5)
scala> a.sum
res53: Int = 15
scala> a.max
res54: Int = 5
scala> a.min
res55: Int = 1
scala> a.length
res56: Int = 5
// 升序
scala> b.sorted
res57: Array[Int] = Array(1, 2, 2, 3, 4, 5, 9)
// 降序
scala> b.sorted.reverse
res58: Array[Int] = Array(9, 5, 4, 3, 2, 2, 1)
2、列表(List)
\quad \quad List列表是scala中最重要的、也是最常用的数据结构。List具备以下性质:
- 可以保存重复的值
- 有先后顺序
\quad \quad 在scala中,也有两种列表,一种是不可变列表、另一种是可变列表。列表是由head(即列表的第一个元素)和tail(出第一个元素之外的其余元素0构成。
2.1 不可变列表
\quad \quad 不可变列表就是列表的元素、长度都是不可变的。
语法
- List()方法
val/var 变量名 = List(元素1,元素2....)
- 使用
Nil
创建一个不可变的空列表【Nil就是一个空的List[Nothing],即一个可以封装任何类型元素但又没有元素的容器。】
val/var 变量名=Nil
- 使用
::
方法创建
var/val 变量名= 元素1::元素2::Nil
例子:
scala> val l=List(1,2,3,4,5)
l: List[Int] = List(1, 2, 3, 4, 5)
scala> val a=Nil
a: scala.collection.immutable.Nil.type = List()
scala> val l2 = 1 :: Nil
l2: List[Int] = List(1)
scala> val l3 = 2 :: l2
l3: List[Int] = List(2, 1)
scala> val l4 = 1 :: 2 :: 3:: Nil
l4: List[Int] = List(1, 2, 3)
2.2 可变列表
- 可变列表就是列表的元素、长度都是可以改变的
定义可变列表
语法
val/var 变量名 = scala.collection.mutable.ListBuffer[元素类型]()
或
val/var 变量名 = scala.collection.mutable.ListBuffer(元素1,元素2....)
- 若不想每次都写那么长的
scala.collection.mutable.ListBuffer
,可先导入import scala.collection.mutable.ListBuffer
包,然后直接写ListBuffer
即可
添加/修改/删除/插入元素,转换
- 使用
+=
添加元素 - 使用
-=
删除元素 - 使用
++=
追加一个列表 - 使用
insert
指定位置插入元素
// 导入包
scala> import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ListBuffer
// 定义可变列表
scala> val a=ListBuffer(1,2,3)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3)
// 查询元素
scala> a(1)
res72: Int = 2
// 添加元素
scala> a+=(2,3,4)
res73: a.type = ListBuffer(1, 2, 3, 2, 3, 4)
// 添加列表
scala> a++=List(9,8)
res74: a.type = ListBuffer(1, 2, 3, 2, 3, 4, 9, 8)
// 删除元素
scala> a-=2
res75: a.type = ListBuffer(1, 3, 2, 3, 4, 9, 8)
// 插入元素
scala> a.insert(0,10)
scala> a
res79: scala.collection.mutable.ListBuffer[Int] = ListBuffer(10, 1, 3, 2, 3, 4, 9, 8)
2.3 可变列表、不可变列表、数组之间的转换
- 使用
tolist
转换为List - 使用
Array
转换为Array
scala> a.toList
res76: List[Int] = List(1, 3, 2, 3, 4, 9, 8)
scala> a.toArray
res77: Array[Int] = Array(1, 3, 2, 3, 4, 9, 8)
2.4 列表常用方法
-
判断列表是否为空(isEmpty)
-
拼接两个列表(++)
-
获取列表的首个元素(head)和剩余部分(tail)
-
反转列表(reverse)
-
获取前缀(take)、获取后缀(drop)
- a.take(n) : 获取列表前n个元素
- a.drop(n): 获取列表后n个元素
-
扁平化即压平(flaten)
- 扁平化是将列表中的列表中的所有元素放到一个列表中
-
拉链(zip)和拉开(unzip)
- 拉链:使用zip将两个列表,组合成一个元素为元组的列表,也就是说将两列表中的元素一 一对应
- 拉开:使用unzip将一个包含元组的列表,解开成包含两个列表的元组
-
转换字符串(toString):默认分隔符为逗号
-
生成字符串(mkString):默认没有分割符,不过可以将元素以任意的分割符拼接起来。
-
并集(union)
-
交集(intersect)
-
差集(diff)
例子:
// 创建列表a
scala> val a=List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)
// 判断是否为空
scala> a.isEmpty
res80: Boolean = false
// 创建列表b
scala> val b=List(9,8,7)
b: List[Int] = List(9, 8, 7)
// 拼接列表a和b
scala> a++b
res81: List[Int] = List(1, 2, 3, 4, 9, 8, 7)
// 获取首元素
scala> a.head
res82: Int = 1
// 获取剩余元素,看其实也是一个列表形式,他与head共同组成列表
scala> a.tail
res83: List[Int] = List(2, 3, 4)
// 反转列表
scala> a.reverse
res84: List[Int] = List(4, 3, 2, 1)
// 获取前几个元素
scala> a.take(3)
res85: List[Int] = List(1, 2, 3)
//获取后两个元素
scala> a.drop(2)
res86: List[Int] = List(3, 4)
// 创建包含多个列表的列表
scala> val b=List(List(1,2),List(3),List(8,9))
b: List[List[Int]] = List(List(1, 2), List(3), List(8, 9))
// 把b亚平
scala> b.flatten
res87: List[Int] = List(1, 2, 3, 8, 9)
// 创建列表C
scala> val c=List("xiaoming","xiaohong","zhangsan","liming")
c: List[String] = List(xiaoming, xiaohong, zhangsan, liming)
//拉链,一一对应
scala> a.zip(c)
res88: List[(Int, String)] = List((1,xiaoming), (2,xiaohong), (3,zhangsan), (4,liming))
// 将上面的拉链再次拉开
scala> res88.unzip
res89: (List[Int], List[String]) = (List(1, 2, 3, 4),List(xiaoming, xiaohong, zhangsan, liming))
// 转换成字符串形式
scala> a.toString
res91: String = List(1, 2, 3, 4)
// mkString形式
scala> a.mkString
res92: String = 1234
scala> a.mkString(";")
res93: String = 1;2;3;4
// 并集
scala> a
res95: List[Int] = List(1, 2, 3, 4)
scala> val e=List(2,4,6,7,8)
e: List[Int] = List(2, 4, 6, 7, 8)
scala> a.union(e)
res96: List[Int] = List(1, 2, 3, 4, 2, 4, 6, 7, 8)
// 可以使用distinct去重
scala> a.union(e).distinct
res97: List[Int] = List(1, 2, 3, 4, 6, 7, 8)
//交集
scala> a.intersect(e)
res98: List[Int] = List(2, 4)
//差集,a在e中不存在的元素
scala> a.diff(e)
res99: List[Int] = List(1, 3)
3、元组(Tuple)
\quad \quad 元组元素是不可变的,但元组可以包含不同类型的元素。元组的值是通过将单个的值包含在圆括号中构成的。
3.1 定义元组
语法
- 使用圆括号来定义元组
val/var 元组名=(元素1,元素2,...)
new Tuplen
,n是指元组有多少个元素
val/var 元组名 = new Tuple3(1, 3.14, "Fred",...)
- 使用尽头来定义元组(元组只有两个元素)
val/var 元组名 = 元素1->元素2
例子:
scala> val t=(2,3,"hi")
t: (Int, Int, String) = (2,3,hi)
scala> val t=new Tuple3(1,3.14,"hello")
t: (Int, Double, String) = (1,3.14,hello)
// 有多少个元素,就写几
scala> val t=new Tuple3(1,3.14)
<console>:15: error: not enough arguments for constructor Tuple3: (_1: T1, _2: T2, _3: T3)(T1, T2, T3).
Unspecified value parameter _3.
val t=new Tuple3(1,3.14)
^
scala> val t=1->2
t: (Int, Int) = (1,2)
// 尽头的方式只能有两个元素
scala> val t=1->2->3
t: ((Int, Int), Int) = ((1,2),3)
3.2 访问元组
\quad \quad
使用_1、_2、_3
…来访问元组中的元素,_1表示访问第一个元素,依次类推。
scala> val t=(1,2,3,4)
t: (Int, Int, Int, Int) = (1,2,3,4)
scala> t._1
res101: Int = 1
3.3 迭代元组
\quad \quad
可以使用 Tuple.productIterator()
方法来迭代输出元组的所有元素:
scala> t
res102: (Int, Int, Int, Int) = (1,2,3,4)
scala> t.productIterator.foreach{ i =>println("Value = " + i )}
Value = 1
Value = 2
Value = 3
Value = 4
3.4 元组转为字符串
- toString方法
scala> val t=(2,3,"hi")
t: (Int, Int, String) = (2,3,hi)
scala> println("连接后的字符串:"+t.toString())
连接后的字符串为字符串:(2,3,hi)
4、Set集合
- 元素无序,不可重复
- 创建后set会自动去重
- 遍历方法同数组、List
- Scala 集合分为可变的和不可变的集合。
4.1 不可变集
- 默认情况下,Scala 使用的是不可变集合,
语法
- 空的不可变集
val/var 变量名 = Set[元素类型]()
- 给定元素创建不可变集
val/var 变量名 = Set(元素1,元素2,......)
4.2 可变集
- 如果你想使用可变集合,需要引
scala.collection.mutable.Set
包。
scala> val a=scala.collection.mutable.Set(1,2,3,2)
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3)
4.3 常用操作
scala> a.size
res109: Int = 3
scala> for(i<-a) println(i)
1
2
3
scala> a-=1
res111: a.type = Set(2, 3)
- 其实这些集合之间的方法大部分都是通用的
- 更多集合方法见菜鸟教程
5、Map(映射)
-
Map(映射)是一种可迭代的键值对(key/value)结构。
-
所有的值都可以通过键来获取。
-
Map 中的键都是唯一的。
-
Map 也叫哈希表(Hash tables)。
-
Map 有两种类型,可变与不可变,区别在于可变对象可以修改它,而不可变对象不可以。
5.1 不可变Map
- 默认情况下 Scala 使用不可变 Map。
语法
val/var 变量名 = Map(键->值,键->值,...)
或
val/var 变量名 = Map((键,值),(键,值),...)
例子
scala> val n_a=Map("lisi"->3,"zj"->4)
n_a: scala.collection.immutable.Map[String,Int] = Map(lisi -> 3, zj -> 4)
5.2 可变集合
- 如果你需要使用可变集合,你需要显式的引
入 import scala.collection.mutable.Map
类
scala> val b=scala.collection.mutable.Map("lisi"->3,"zj"->4)
b: scala.collection.mutable.Map[String,Int] = Map(lisi -> 3, zj -> 4)
5.3 常用操作
- 获取值 ( map(key) )
- 获取所有key( map.keys )
- 获取所有value( map.values )
- 遍历map集合
- getOrElse:(key: String, default: => B1),查找键,如果键不存在返回B1值
- 增加key,value对
- 删除key
scala> val b=scala.collection.mutable.Map("lisi"->3,"zj"->4)
b: scala.collection.mutable.Map[String,Int] = Map(lisi -> 3, zj -> 4)
scala> b("zj")
res113: Int = 4
scala> b.keys
res114: Iterable[String] = Set(lisi, zj)
scala> b.values
res115: Iterable[Int] = HashMap(3, 4)
scala> for((x,y)<-b) println(s"$x $y")
lisi 3
zj 4
// 如果lisi不存在表中,则返回-1
scala> b.getOrElse("lisi",-1)
res120: Int = 3
scala> b+"wang"->17
res121: (String, Int) = (Map(lisi -> 3, zj -> 4)wang,17)
scala> b - "lisi"
res123: scala.collection.mutable.Map[String,Int] = Map(zj -> 4)
6、Option(选项)
-
scala中,Option类型来表示可选值,用来表示一个值是可选的(有值或无值)。
-
Option[T] 是一个类型为 T 的可选值的容器,这种类型的数据有两种形式:
- 如果值存在, Option[T] 就是一个 Some[T]
- 如果不存在, Option[T] 就是对象 None 。
scala> val myMap: Map[String, String] = Map("key1" -> "value")
myMap: Map[String,String] = Map(key1 -> value)
scala> val value1: Option[String] = myMap.get("key1")
value1: Option[String] = Some(value)
scala> val value2: Option[String] = myMap.get("key2")
value2: Option[String] = None
scala>
| println(value1) // Some("value1")
Some(value)
scala> println(value2) // None
None
更多内容参考菜鸟教程
参考资料:
1、https://www.runoob.com/scala/scala-collections.html