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

2020-08-14 本文已影响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语言学习一（数组，元祖，列表，集合，映射）

Array (数组)

定长数组

变长数组

遍历数组

数组的常用算法

求和

最大值

最小值

排序

Turple (元祖)

定义

访问元组

List (列表)

不可变列表

可变列表

初始化列表

列表操作

列表常用操作

判断列表是否为空

拼接两个列表

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

反转列表

获取列表前缀和后缀

扁平化

拉链与拉开

转换字符串

生成字符串

并集

交集

差集

Set (集合)

不可变集

可变集

Map (映射)

不可变Map

可变Map

Map基本操作

猜你喜欢

热点阅读

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

Array (数组)

定长数组

变长数组

遍历数组

数组的常用算法

求和

最大值

最小值

排序

Turple (元祖)

定义

访问元组

List (列表)

不可变列表

可变列表

初始化列表

列表操作

列表常用操作

判断列表是否为空

拼接两个列表

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

反转列表

获取列表前缀和后缀

扁平化

拉链与拉开

转换字符串

生成字符串

并集

交集

差集

Set (集合)

不可变集

可变集

Map (映射)

不可变Map

可变Map

Map基本操作

猜你喜欢

热点阅读

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