scala 列表List常用操作

列表常用操作

以下是列表常用的操作

1. 判断列表是否为空（isEmpty）
2. 拼接两个列表（++ :: ::: ）
3. 获取列表的首个元素（head）和剩余部分(tail)
4. 反转列表（reverse）
5. 获取前缀（take）、获取后缀（drop）
6. 扁平化（flaten）
7. 拉链（zip）和拉开（unzip）
8. 转换字符串（toString）
9. 生成字符串（mkString）
10. 并集（union）(合并,跟++ 操作效果相同)
11. 交集（intersect）(取相同的)
12. 差集（diff）(获取a1在a2中不存在的元素)

判断列表是否为空

示例

• 定义一个列表，包含以下元素：1,2,3,4
• 使用isEmpty判断列表是否为空

参考代码

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
• 使用++将两个列表拼接起来

参考代码

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)

a = List(1, 2, 3)
b = List(4, 5, 6)

a++b = 	List(1, 2, 3, 4, 5, 6)
a::b = 	List(List(1, 2, 3), 4, 5, 6)
a ::: b  =  	List(1, 2, 3, 4, 5, 6)
a ::: b ::: (a::b)  =  	List(1, 2, 3, 4, 5, 6, List(1, 2, 3), 4, 5, 6)

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

示例

• 定义一个列表，包含以下几个元素：1,2,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)

反转列表

示例

• 定一个列表，包含以下元素：1,2,3

• 使用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)

获取列表前缀和后缀

示例

• 定义一个列表，包含以下元素：1,2,3,4,5
• 使用take方法获取前缀（前三个元素）：1,2, 3
• 使用drop方法获取后缀（除前三个以外的元素）：4,5

参考代码

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)

参考代码

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)

拉链与拉开

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

示例

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

参考代码

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))

示例

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

参考代码

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

转换字符串

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

示例

• 定义一个列表，包含以下元素：1,2,3,4
• 使用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)

生成字符串

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

示例

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

参考代码

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(合并,跟++ 操作效果相同)

union表示对两个列表取并集，不去重, 跟++ 操作效果相同

示例

• 定义第一个列表，包含以下元素：1,2,3,4
• 定义第二个列表，包含以下元素：3,4,5,6
• 使用union操作，获取这两个列表的并集
• 使用distinct操作，去除重复的元素

参考代码

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(取相同的)

intersect表示对两个列表取交集

示例

• 定义第一个列表，包含以下元素：1,2,3,4
• 定义第二个列表，包含以下元素：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在a2中不存在的元素)

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

示例

• 定义第一个列表，包含以下元素：1,2,3,4
• 定义第二个列表，包含以下元素：3,4,5,6
• 使用diff获取这两个列表的差集

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)

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

示例

• 定义第一个列表，包含以下元素：1,2,3,4
• 定义第二个列表，包含以下元素：3,4,5,6
• 使用diff获取这两个列表的差集

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)