2021年大数据常用语言Scala(十六):基础语法学习 列表 List 重点掌握

2021-10-11 10:25:54 浏览数 (1)


列表 List 重点掌握

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

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

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

不可变列表定义

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

语法

使用List(元素1, 元素2, 元素3, ...)来创建一个不可变列表,语法格式:

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

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

val/var 变量名 = Nil

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

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

[!TIP]

使用::拼接方式来创建列表,必须在最后添加一个Nil

示例一

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

参考代码

代码语言:javascript复制
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

示例二

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

参考代码

代码语言:javascript复制
scala> val a = Nil
a: scala.collection.immutable.Nil.type = List()

示例三

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

参考代码

代码语言:javascript复制
scala> val a = -2 :: -1 :: Nil
a: List[Int] = List(-2, -1)

可变列表

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

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

[!NOTE]

  • 可变集合都在mutable包中
  • 不可变集合都在immutable包中(默认导入)

定义

使用ListBuffer[元素类型]()创建空的可变列表,语法结构:

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

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

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

示例一

创建空的整形可变列表

参考代码

代码语言:javascript复制
  scala> val a = ListBuffer[Int]()
  a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

示例二

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

参考代码

代码语言:javascript复制
scala> val a = ListBuffer(1,2,3,4)
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

可变列表操作

  • 获取元素(使用括号访问(索引值))
  • 添加元素( =)
  • 追加一个列表( =)
  • 更改元素(使用括号获取元素,然后进行赋值)
  • 删除元素(-=)
  • 转换为List(toList)转换为不可变列表
  • 转换为Array(toArray)转换为定长数组

说一下,

定长数组Array 长度固定, 元素可变

不可变List, 长度固定, 元素不可变

大家不要记混淆了, 怎么记呢, 看名字

定长数组, 就是只是固定长度, 元素可变

不可变List, 不可变了就是都不可变了

可变列表示例

定义一个可变列表包含以下元素:1,2,3

获取第一个元素

添加一个新的元素:4

追加一个列表,该列表包含以下元素:5,6,7

删除元素7

将可变列表转换为不可变列表

将可变列表转换为数组

参考代码

代码语言:javascript复制
// 导入不可变列表
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,2,3,4
  • 使用isEmpty判断列表是否为空

参考代码

代码语言:javascript复制
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> a.isEmpty
res51: Boolean = false

拼接两个列表

示例

  • 有两个列表,分别包含以下元素1,2,3和4,5,6
  • 使用 将两个列表拼接起来

和 = 不同的是, = 是 追加, 也就是 将一个追加到另一个

是两个串联在一起 形成一个新的, 这个概念不要混淆

如 a = b, 最终是a 变化了 加长了

a b 执行完后, a b 均不变, 但结果是a和b的串联, 需要用变量接收

参考代码

代码语言:javascript复制
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> a    b
res52: List[Int] = List(1, 2, 3, 4, 5, 6)

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

示例

  • 定义一个列表,包含以下几个元素:1,2,3
  • 使用head方法,获取列表的首个元素(返回值是单个元素)
  • 使用tail方法,获取除第一个元素以外的元素,它也是一个列表(返回值是剩余元素列表)

参考代码

代码语言:javascript复制
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)

反转列表

示例

  • 定一个列表,包含以下元素:1,2,3
  • 使用reverse方法将列表的元素反转

注意, 列表本身不会变, 只是生成了一个新结果, 需要被变量接收

代码语言:javascript复制
scala> val a = List(1,2,3)
a: List[Int] = List(1, 2, 3)

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

获取列表前缀和后缀

示例

  • 定义一个列表,包含以下元素:1,2,3,4,5
  • 使用take方法获取前缀(前三个元素):1,2, 3(返回的也是列表)
  • 使用drop方法获取后缀(除前三个以外的元素):4,5(返回的也是列表)

是不是和head 和tail 很像?

我们可以认为head 就是take(1)然后取出值(因为head返回是单个元素, take返回list)

tail 就是 drop(1)

参考代码

代码语言:javascript复制
scala> val a = List(1,2,3,4,5)
a: List[Int] = List(1, 2, 3, 4, 5)

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

scala> a.drop(3)
res60: List[Int] = List(4, 5)

扁平化(压平)

扁平化表示将列表中的列表中的所有元素放到一个列表中。

示例

  • 有一个列表,列表中又包含三个列表,分别为:List(1,2)、List(3)、List(4,5)
  • 使用flatten将这个列表转换为List(1,2,3,4,5)

参考代码

代码语言:javascript复制
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
res0: List[Int] = List(1, 2, 3, 4, 5)

注意, 一次flatten只能解开一层嵌套

如:

代码语言:javascript复制
scala> l6
res19: List[List[List[Int]]] = List(List(List(1, 2), List(3, 4)), List(List(5, 6), List(7, 8)))

scala> l6.flatten
res20: List[List[Int]] = List(List(1, 2), List(3, 4), List(5, 6), List(7, 8))

如果要解开两层或者多层嵌套呢?

代码语言:javascript复制
scala> l6.flatten.flatten
res21: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)

注意, 如果元素不均衡, 就不好弄了, 需要手动处理了

代码语言:javascript复制
scala> val l5 = List(List(1 ,2), List(3 ,4), List(List(5, 6), 7))
l5: List[List[Any]] = List(List(1, 2), List(3, 4), List(List(5, 6), 7))

scala> l5.flatten
res17: List[Any] = List(1, 2, 3, 4, List(5, 6), 7)
// 这里有5, 6没有解开, 但是不能继续串 flatten了, 再串一次, 对5, 6有效 对别的元素无效, 会报错, 如:
scala> l5.flatten.flatten
<console>:13: error: No implicit view available from Any => scala.collection.GenTraversableOnce[B].
 l5.flatten.flatten

所以使用flatten要注意, 数据要规范才可用

也就是说, 目前的flatten方法 适合规范数据, 如果是示例中这样的数据 ,可能需要大家自行实现自己的myFlatten方法啦. 相信大家可以做到的

拉链与拉开

  • 拉链:使用zip将两个列表,组合成一个元素为元组的列表
  • 拉开:将一个包含元组的列表,解开成包含两个列表的元组

示例

  • 有两个列表
    • 第一个列表保存三个学生的姓名,分别为:zhangsan、lisi、wangwu
    • 第二个列表保存三个学生的年龄,分别为:19, 20, 21
  • 使用zip操作将两个列表的数据"拉"在一起,形成 zhangsan->19, lisi ->20, wangwu->21

参考代码

代码语言:javascript复制
scala> val a = List("zhangsan", "lisi", "wangwu")
a: List[String] = List(zhangsan, lisi, wangwu)

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

scala> a.zip(b)
res1: List[(String, Int)] = List((zhangsan,19), (lisi,20), (wangwu,21))

// 注意: 结果是 List 的元素是一个个元组,  然后一个个元组的内容是两个元素(名字,年龄)

示例

  • 将上述包含学生姓名、年龄的元组列表,解开成两个列表

参考代码

代码语言:javascript复制
scala> res1.unzip
res2: (List[String], List[Int]) = (List(zhangsan, lisi, wangwu),List(19, 20, 21))

// 注意: 结果是 一个 元组 包含了两个元素, 这两个元素分别是两个list ,第一个list存放的字符串, 第二个list存放的int // 也就是如果想要得到zhangsan   需要这样: res2._1(0)  先取元组的元素1, 然后取元素1的元素1 // 注意角标, 元组从1开始, list从0开始

转换字符串

toString方法可以返回List中的所有元素

示例

  • 定义一个列表,包含以下元素:1,2,3,4
  • 使用toString输出该列表的元素

参考代码

代码语言:javascript复制
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)

List(1, 2, 3, 4) 整体都是string哦, 并不是只是(1, 2, 3, 4)

生成字符串

mkString方法,可以将元素以分隔符拼接起来。默认没有分隔符

示例

  • 定义一个列表,包含以下元素1,2,3,4
  • 使用mkString,用冒号将元素都拼接起来

参考代码

代码语言:javascript复制
scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> a.mkString
res7: String = 1234

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

并集

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

示例

  • 定义第一个列表,包含以下元素:1,2,3,4
  • 定义第二个列表,包含以下元素:3,4,5,6
  • 使用union操作,获取这两个列表的并集(类似拼接)
  • 使用distinct操作,去除重复的元素(list的方法, 去重)

参考代码

代码语言:javascript复制
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表示对两个列表取交集

取出两个列表中一样的元素

示例

  • 定义第一个列表,包含以下元素:1,2,3,4
  • 定义第二个列表,包含以下元素:3,4,5,6
  • 使用intersect操作,获取这两个列表的交集
代码语言:javascript复制
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中不存在的元素

同理 a2.diff(a1) 就是取 a2 在 a1中不存在的元素. 不要混淆.

示例

  • 定义第一个列表,包含以下元素:1,2,3,4
  • 定义第二个列表,包含以下元素:3,4,5,6
  • 使用diff获取这两个列表的差集
代码语言:javascript复制
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)

0 人点赞