Scala入门4之集合【数组、列表、元组、Set集合、Map（映射）、Option（选项）】

最新推荐文章于 2024-04-28 18:44:27 发布

珞沫

最新推荐文章于 2024-04-28 18:44:27 发布

阅读量305

点赞数

分类专栏： Scala 文章标签： scala 列表

本文链接：https://blog.csdn.net/weixin_45666566/article/details/111762819

版权

Scala 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

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

珞沫

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Scala入门4之集合【数组、列表、元组、Set集合、Map（映射）、Option（选项）】

这里写目录标题1、数组1.1 定长数组1.2 变长数组1.3 可变数组转换为定长数组1.4 遍历数组1.4 数组常用方法2、1、数组\quad \quadScala中，数组有两种，定长数组和变长数组1.1 定长数组\quad \quad定长数组指的是数组的长度是不允许改变的语法// 通过指定长度定义数组，然后添加元素val/var 变量名 = new Array[元素类型](数组长度）变量名(所在位置）= 元素值或// 用元素直接初始化数组val/var 变量名 = Array(元素1
复制链接

扫一扫

专栏目录