Scala语言学习一（数组，元祖，列表，集合，映射）

作者: 做个合格的大厂程序员 | 来源:发表于2020-08-14 20:09 被阅读0次

Array (数组)

scala中数组的概念是和Java类似，可以用数组来存放一组数据。scala中，有两种数组，一种是定

长数组，另一种是变长数组

定长数组

定长数组指的是数组的长度是不允许改变的

// 通过指定长度定义数组 
val/var 变量名 = Array[元素类型](数组长度) 

// 用元素直接初始化数组 
val/var 变量名 = Array(元素1, 元素2, 元素3...)

示例一：

定义一个长度为100的整型数组
设置第1个元素为110
打印第1个元素

scala> val a = new Array[Int](100) 
a: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) 

scala> a(0) = 110 
scala> println(a(0)) 
110

示例二：

定义一个包含以下元素的数组
获取数组长度

"java", "scala", "python"

// 定义包含jave、scala、python三个元素的数组 
scala> val a = Array("java", "scala", "python") 
a: Array[String] = Array(java, scala, python) 

scala> a.length 
res17: Int = 3

变长数组

变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素

语法

创建空的ArrayBuffer变长数组，语法结构：
```
val/var a = ArrayBuffer[元素类型]()
```

创建带有初始元素的ArrayBuffer

val/var a = ArrayBuffer(元素1，元素2，元素3....)

需导入ArrayBuffer类 import scala.collection.mutable.ArrayBuffer

定义一个长度为0的整型变长数组

val a = ArrayBuffer[Int]()

定义一个包含以下元素的变长数组

**"hadoop", "storm", "spark" **

scala> val a = ArrayBuffer("hadoop", "storm", "spark") 

a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

添加 / 修改 / 删除元素

使用 += 添加元素
使用 -= 删除元素
使用 ++= 追加一个数组到变长数组

示例:

定义一个变长数组，包含以下元素: "hadoop", "spark", "flink"
往该变长数组添加一个"flume"元素
从该变长数组删除"hadoop"元素
再将一个数组，该数组包含"hive", "sqoop"追加到变长数组中

// 定义变长数组 
scala> val a = ArrayBuffer("hadoop", "spark", "flink") 
a: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, spark, flink)

// 追加一个元素 
scala> a += "flume" 
res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)

// 删除一个元素 
scala> a -= "hadoop" 
res11: a.type = ArrayBuffer(spark, flink, flume)

// 追加一个数组 
scala> a ++= Array("hive", "sqoop") 
res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

遍历数组

可以使用以下两种方式来遍历数组：

使用 for表达式直接遍历数组中的元素
使用索引遍历数组中的元素

示例：

定义一个数组，包含以下元素1,2,3,4,5
使用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

数组的常用算法

求和——sum方法
求最大值——max方法
求最小值——min方法
排序——sorted方法

求和

数组中的 sum 方法可以将所有的元素进行累加，然后得到结果

示例:

定义一个数组，包含以下几个元素（1,2,3,4)
请计算该数组的和

scala> val a = Array(1,2,3,4) 
a: Array[Int] = Array(1, 2, 3, 4) 

scala> a.sum 
res49: Int = 10

最大值

数组中的 max 方法，可以获取到数组中的最大的那个元素值

示例

定义一个数组，包含以下几个元素（4,1,2,4,10）
获取数组的最大值

scala> val a = Array(4,1,2,4,10) 
a: Array[Int] = Array(4, 1, 2, 4, 10) 

scala> a.max 
res50: Int = 10

最小值

数组的 min 方法，可以获取到数组中最小的那个元素值

示例

定义一个数组，包含以下几个元素（4,1,2,4,10）
获取数组的最小值

scala> val a = Array(4,1,2,4,10) 
a: Array[Int] = Array(4, 1, 2, 4, 10) 

scala> a.min 
res51: Int = 1

排序

数组的 sorted 方法，可以对数组进行升序排序。而 reverse 方法，可以将数组进行反转，从而

实现降序排序

示例

定义一个数组，包含以下几个元素（4,1,2,4,10）
对数组进行升序排序、降序排序

// 升序排序 
scala> a.sorted 
res53: Array[Int] = Array(1, 2, 4, 4, 10) 

// 降序 
scala> a.sorted.reverse 
res56: Array[Int] = Array(10, 4, 4, 2, 1)

Turple (元祖)

元组可以用来包含一组不同类型的值。例如：姓名，年龄，性别，出生年月。元组的元素是不可变

的。

定义

语法

使用括号来定义元组

val/var 元组 = (元素1, 元素2, 元素3....)

使用尽头来定义元素（元组只有两个元素）

val/var 元组 = 元素1->元素2

示例：使用括号

// 可以直接使用括号来定义一个元组 
scala> val a = (1, "张三", 20, "北京市") 
a: (Int, String, Int, String) = (1,张三,20,北京市)

示例：使用箭头（元组只有两个元素）

scala> val a = 1->2 
a: (Int, Int) = (1,2)

访问元组

使用_1、_2、_3....来访问元组中的元素，_1表示访问第一个元素，依次类推

// 可以直接使用括号来定义一个元组 
scala> val a = (1, "张三", 20, "北京市") 
a: (Int, String, Int, String) = (1,张三,20,北京市) 

// 获取第一个元素 
scala> a._1 
res57: Int = 1 

// 获取第二个元素 
scala> a._2 
res58: String = 张三 

// 不能修改元组中的值 
scala> a._1 = 2 
<console>:13: error: reassignment to val a._1 = 2 ^

List (列表)

List是scala中最重要的、也是最常用的数据结构。List具备以下性质：

可以保存重复的值
有先后顺序

在scala中，也有两种列表，一种是不可变列表、另一种是可变列表

不可变列表

不可变列表就是列表的元素、长度都是不可变的。

语法

val/var 变量名 = List(元素1, 元素2, 元素3...)

使用 Nil 创建一个不可变的空列表

val/var 变量名 = Nil

使用 :: 方法创建一个不可变列表

val/var 变量名 = 元素1 :: 元素2 :: Nil

示例一

创建一个不可变列表，存放以下几个元素（1,2,3,4）

scala> val a = List(1,2,3,4) 
a: List[Int] = List(1, 2, 3, 4)

示例二

使用Nil创建一个不可变的空列表

scala> val a = Nil 
a: scala.collection.immutable.Nil.type = List()

示例三

使用 :: 方法创建列表，包含-2、-1两个元素

scala> val a = -2 :: -1 :: Nil 
a: List[Int] = List(-2, -1)

可变列表

可变列表就是列表的元素、长度都是可变的。

要使用可变列表，先要导入import scala.collection.mutable.ListBuffer

Tips:

可变集合都在 mutable 包中
不可变集合都在 immutable 包中（默认导入）

初始化列表

使用ListBuffer元素类型创建空的可变列表，语法结构：

val/var 变量名 = ListBuffer[Int]()

使用ListBuffer(元素1, 元素2, 元素3...)创建可变列表，语法结构：

val/var 变量名 = ListBuffer(元素1，元素2，元素3...)

示例一

创建空的可变列表

scala> val a = ListBuffer[Int]() 
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

示例二

创建一个可变列表，包含以下元素：1,2,3,4

scala> val a = ListBuffer(1,2,3,4) 
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

列表操作

获取元素（使用括号访问 (索引值) ）
添加元素（ += ）
追加一个列表（ ++= ）
更改元素（使用括号获取元素，然后进行赋值）
删除元素（ -= ）
转换为List（ toList ）
转换为Array（ toArray ）

示例一

定义一个可变列表包含以下元素：1,2,3
获取第一个元素
添加一个新的元素：4
追加一个列表，该列表包含以下元素：5,6,7
删除元素7
将可变列表转换为不可变列表
将可变列表转换为数组

// 导入不可变列表 
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(0) 
res19: Int = 1

// 追加一个元素 
scala> a += 4 
res20: a.type = ListBuffer(1, 2, 3, 4) 

// 追加一个列表 
scala> a ++= List(5,6,7) 
res21: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7) 

// 删除元素 
scala> a -= 7 
res22: a.type = ListBuffer(1, 2, 3, 4, 5, 6) 

// 转换为不可变列表 
scala> a.toList 
res23: List[Int] = List(1, 2, 3, 4, 5, 6) 

// 转换为数组 
scala> a.toArray 
res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)

列表常用操作

判断列表是否为空（ isEmpty ）
拼接两个列表（ ++ ）
获取列表的首个元素（ head ）和剩余部分( tail )
反转列表（ reverse ）
获取前缀（ take ）、获取后缀（ drop ）
扁平化（ flaten ）
拉链（ zip ）和拉开（ unzip ）
转换字符串（ toString ）
生成字符串（ mkString ）
并集（ union ）
交集（ intersect ）
差集（ diff ）

判断列表是否为空

示例1：使用length方法来获取列表长度

scala> val a = List(1,2,3,4) 
a: List[Int] = List(1, 2, 3, 4)

scala> a.length 
res0: Int = 4

使用isEmpty代替 length == 0，效率更高

拼接两个列表

示例2：使用++方法来拼接连接列表来形成一个新的列表

scala> val a = List(1,2,3) 
a: List[Int] = List(1, 2, 3) 

scala> val b = List(4,5,6) 
b: List[Int] = List(4, 5, 6) 

scala> val c = a ++ b 
c: List[Int] = List(1, 2, 3, 4, 5, 6)

获取列表的首个元素和剩余部分

示例3：获取列表的首个元素和剩余部分

使用head方法，获取列表的首个元素
使用tail方法，获取除第一个元素以外的元素，它也是一个列表

scala> val a = List(1,2,3) 
a: List[Int] = List(1, 2, 3) 

scala> a.head 
res4: Int = 1 

scala> a.tail 
res5: List[Int] = List(2, 3)

反转列表

示例4：使用reverse方法将列表的元素反转

scala> val a = List(1,2,3) 
a: List[Int] = List(1, 2, 3) 

scala> a.reverse 
res6: List[Int] = List(3, 2, 1)

获取列表前缀和后缀

示例5：获取列表的前缀、后缀以

使用take方法获取前n个元素

scala> val a = List(1,2,3,4,5) 
a: List[Int] = List(1, 2, 3, 4, 5) 

// 获取列表a的前3个元素 
scala> a.take(3) 
res10: List[Int] = List(1, 2, 3)

使用drop方法获取除了前3个元素以外的元素

scala> val a = List(1,2,3,4, 5) 
a: List[Int] = List(1, 2, 3, 4, 5) 

// 获取除了前3个元素以外的元素 
scala> a.drop(3) 
res11: List[Int] = List(4, 5)

扁平化

示例6：扁平化操作，扁平化表示将列表中的列表中的所有元素放到一个列表中。

使用flatten方法来进行扁平化

scala> val a = List(List(1,2), List(3), List(4,5)) 
a: List[List[Int]] = List(List(1, 2), List(3), List(4, 5))

scala> a.flatten 
res15: List[Int] = List(1, 2, 3, 4, 5)

拉链与拉开

示例7：拉链与拉开

使用zip将两个列表，组合成一个元素为元组的列表

scala> val a = List("张三", "李四", "王五") 
a: List[String] = List(张三, 李四, 王五) 

scala> val b = List(19, 20, 21) 
b: List[Int] = List(19, 20, 21) 

scala> a.zip(b) 
res16: List[(String, Int)] = List((张三,19), (李四,20), (王五,21))

使用unzip将一个包含元组的列表，解开成两个列表的元组

scala> res16.unzip 
res17: (List[String], List[Int]) = (List(张三, 李四, 王五),List(19, 20, 21)

转换字符串

示例8：toString返回列表的标准字符串表现形式

scala> val a = List(1,2,3,4) 
a: List[Int] = List(1, 2, 3, 4) 

scala> println(a.toString) 
List(1, 2, 3, 4)

生成字符串

示例9：mkString表示使用什么样的分隔符来展示列表

scala> a.mkString(",") 
res20: String = 1,2,3,4 

// 可以调用mkString的另一种重载方式，加上前缀和后缀 
scala> a.mkString("[", ":", "]") 
res22: String = [1:2:3:4]

并集

union表示对两个列表取并集，不去重

scala> val a1 = List(1,2,3,4) 
a1: List[Int] = List(1, 2, 3, 4) 

scala> val a2 = List(3,4,5,6) 
a2: List[Int] = List(3, 4, 5, 6) 

// 并集操作 
scala> a1.union(a2) 
res17: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6) 

// 可以调用distinct去重 
scala> a1.union(a2).distinct 
res18: List[Int] = List(1, 2, 3, 4, 5, 6)

交集

intersect表示对两个列表取交集，不去重

scala> val a1 = List(1,2,3,4) 
a1: List[Int] = List(1, 2, 3, 4) 

scala> val a2 = List(3,4,5,6) 
a2: List[Int] = List(3, 4, 5, 6) 

scala> a1.intersect(a2) 
res19: List[Int] = List(3, 4)

差集

diff表示对两个列表取差集，例如： a1.diff(a2)，表示将a1中不包含a2中的元素

scala> val a1 = List(1,2,3,4) 
a1: List[Int] = List(1, 2, 3, 4) 

scala> val a2 = List(3,4,5,6) 
a2: List[Int] = List(3, 4, 5, 6) 

scala> a1.diff(a2) 
res24: List[Int] = List(1, 2)

Set (集合)

Set(集)是代表没有重复元素的集合。Set具备以下性质：

元素不重复
不保证插入顺序

scala中的集也分为两种，一种是不可变集，另一种是可变集。

不可变集

语法

创建一个空的不可变集，语法格式：

val/var 变量名 = Set[类型]()

给定元素来创建一个不可变集，语法格式：

val/var 变量名 = Set[类型](元素1, 元素2, 元素3...)

基本操作

获取集的大小（ size ）
遍历集（和遍历数组一致）
添加一个元素，生成一个Set（ + ）
拼接两个集，生成一个Set（ ++ ）
拼接集和列表，生成一个Set（ ++ ）

案例

创建一个集，包含以下元素：1,1,2,3,4,5
获取集的大小
遍历集，打印每个元素
删除元素1
拼接另一个集（6, 7, 8)
拼接一个列表(6,7,8, 9)

// 创建集 
scala> val a = Set(1,1,2,3,4,5) 
a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4) 

// 获取集的大小 
scala> a.size res0: Int = 5 

// 遍历集 
scala> for(i <- a) println(i) 

// 删除一个元素 
scala> a - 1 
res5: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4) 

// 拼接两个集 
scala> a ++ Set(6,7,8) 
res2: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4) 

// 拼接集和列表 
scala> a ++ List(6,7,8,9) 
res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

可变集

要使用可变集，必须要手动导入：import scala.collection.mutable.Set

示例

定义一个可变集，包含以下元素: 1,2,3, 4
添加元素5到可变集中
从可变集中移除元素1

scala> val a = Set(1,2,3,4) 
a: scala.collection.mutable.Set[Int] = Set(1, 2, 3, 4) 

// 添加元素 
scala> a += 5 
res25: a.type = Set(1, 5, 2, 3, 4) 

// 删除元素 
scala> a -= 1 
res26: a.type = Set(5, 2, 3, 4)

Map (映射)

Map可以称之为映射。它是由键值对组成的集合。在scala中，Map也分为不可变Map和可变

Map。

不可变Map

定义语法

val/var map = Map(键->值, 键->值, 键->值...) // 推荐，可读性更好

val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

示例

定义一个映射，包含以下学生姓名和年龄数据

"zhangsan", 30

"lisi", 40

获取zhangsan的年龄

scala> val map = Map("zhangsan"->30, "lisi"->40) 
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 40) 

scala> val map = Map(("zhangsan", 30), ("lisi", 30)) 
map: scala.collection.immutable.Map[String,Int] = Map(zhangsan -> 30, lisi -> 30) 

// 根据key获取value 
scala> map("zhangsan") 
res10: Int = 30

可变Map

可变Map需要手动导入 import scala.collection.mutable.Map

定义语法与不可变Map一致。

示例

定义一个映射，包含以下学生姓名和年龄数据

"zhangsan", 30

"lisi", 40
修改zhangsan的年龄为20

scala> val map = Map("zhangsan"->30, "lisi"->40) 
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30) 

// 修改value 
scala> map("zhangsan") = 20

Map基本操作

获取值( map(key) )
获取所有key（ map.keys ）
获取所有value（ map.values ）
遍历map集合
getOrElse
增加key,value对
删除key

示例

定义一个映射，包含以下学生姓名和年龄数据

"zhangsan", 30

"lisi", 40
获取zhagnsan的年龄
获取所有的学生姓名
获取所有的学生年龄
打印所有的学生姓名和年龄
获取wangwu的年龄，如果wangwu不存在，则返回-1
新增一个学生：wangwu, 35
将lisi从可变映射中移除

scala> val map = Map("zhangsan"->30, "lisi"->40) 
map: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30) 

// 获取zhagnsan的年龄 
scala> map("zhangsan") 
res10: Int = 30 

// 获取所有的学生姓名 
scala> map.keys 
res13: Iterable[String] = Set(lisi, zhangsan) 

// 获取所有的学生年龄 
scala> map.values 
res14: Iterable[Int] = HashMap(40, 30) 

// 打印所有的学生姓名和年龄 
scala> for((x,y) <- map) println(s"$x $y") 
lisi 40 zhangsan 30 

// 获取wangwu的年龄，如果wangwu不存在，则返回-1 
scala> map.getOrElse("wangwu", -1) 
res17: Int = -1 

// 新增一个学生：wangwu, 35 
scala> map + "wangwu"->35
res22: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangw u -> 35) 

// 将lisi从可变映射中移除 
scala> map - "lisi" 
res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)

Scala语言学习一 （数组，元祖，列表，集合，映射）