Scala系列6：Scala中Array,BufferArray,元组，list，set，map等集合使用详解

     Scala中集合类的序列有：数组，元组，列表，Set集，Map映射,其中数组，列表，Set,Map又分为可变和不可变两种。下面就此详细展开介绍使用。

0.数组的使用详解

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

0.1 定长数组

定长数组指的是数组的长度是不允许改变的 。通过指定长度定义数组，语法格式如下：

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

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

尖叫提示：

1. 在scala中，数组的泛型使用 [] 来指定

2. 使用 () 来获取元素，角标从0开始。

1. //1.通过初始化定义数组： 数组定义包含jave、scala、python三个元素的数组

2. scala> val a = Array("java", "scala", "python")

3. a: Array[String] = Array(java, scala, python)

4. scala> a.length

5. res17: Int = 3

6. 
   

7. //注意，这种不同类型数据也可以创建到数组里，类型为Any。

8. scala> val a4=Array("a","b",1)

9. a4: Array[Any] = Array(a, b, 1)

10. 
    

11. //2.通过指定长度定义数组，这种指定类型的数组，只能赋值同类型的数据。

12. scala> val a = new Array[Int](100)

13. 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,

14. 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

15. , 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,

16. 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

17. scala> a(0) = 110

18. scala> println(a(0))

19. 110

20. //注意：这种指定类型的数组，只能赋值同类型的数据。

21. scala> a (1)=1

22. scala> a(1)

23. res13: Int = 1

24. scala> a(2)="1b"

25. <console>:16: error: type mismatch;

26. found : String("1b")

27. required: Int

28. a(2)="1b"

29. ^

0.2 变长数组

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

[1.语法格式]：

1. val/var a = ArrayBuffer[元素类型]()   //方式1：创建空的ArrayBuffer变长数组

2. val/var a = ArrayBuffer(元素1，元素2，元素3....) //方式2：创建带有初始元素的ArrayBuffer

[尖叫提示]
创建变长数组，需要提前导入ArrayBuffer类 import scala.collection.mutable.ArrayBuffer

1. scala> import scala.collection.mutable._

2. import scala.collection.mutable._

3. 
   

4. scala> val a = ArrayBuffer("hadoop", "spark", "flink")

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

6. 
   

7. scala> a += "flume"

8. res0: a.type = ArrayBuffer(hadoop, spark, flink, flume)

9. 
   

[2.变长数组的操作]

• 添加/修改/删除元素

• 使用 += 添加元素

• 使用 -= 删除元素

• 使用 ++= 追加一个数组到变长数组

1. // 1.定义变长数组

2. scala> val a = ArrayBuffer("hadoop", "spark", "flink")

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

4. //2. 追加一个元素

5. scala> a += "flume"

6. res10: a.type = ArrayBuffer(hadoop, spark, flink, flume)

7. // 3.删除一个元素

8. scala> a -= "hadoop"

9. res11: a.type = ArrayBuffer(spark, flink, flume)

10. // 4. 追加一个数组

11. scala> a ++= Array("hive", "sqoop")

12. res12: a.type = ArrayBuffer(spark, flink, flume, hive, sqoop)

0.3数组的其他操作（定长数组和变长数组）

• 遍历数组方式1：使用 for表达式 直接遍历数组中的元素

• 遍历数组方式2：使用 索引 遍历数组中的元素

• 数组求和——sum方法

• 数组求最大值——max方法

• 数组求最小值——min方法

• 数组排序——sorted方法

1. //1.使用for直接遍历数组元素

2. scala> val a = Array(1,2,3,4,5)

3. a: Array[Int] = Array(1, 2, 3, 4, 5)

4. scala> for(i<-a) println(i)

5. 1

6. 2

7. 3

8. 4

9. 5

10. //2.使用for表达式基于索引下标遍历，并打印数组的元素

11. scala> val a = Array(1,2,3,4,5)

12. a: Array[Int] = Array(1, 2, 3, 4, 5)

13. scala> for(i <- 0 to a.length - 1) println(a(i))

14. 1

15. 2

16. 3

17. 4

18. 5

19. scala> for(i <- 0 until a.length) println(a(i))

20. 1

21. 2

22. 3

23. 4

24. 5

25. 【尖叫提示】

26. 0 until n——生成一系列的数字，包含0，不包含n，左闭右开

27. 0 to n ——包含0，也包含n

28. 
    

29. //3.数组求和，要针对数值型，否则报错

30. scala> val a = Array(1,2,3,4)

31. a: Array[Int] = Array(1, 2, 3, 4)

32. scala> a.sum

33. res49: Int = 10

34. 
    

35. //4.求数组最大值

36. scala> val a = Array(4,1,2,4,10)

37. a: Array[Int] = Array(4, 1, 2, 4, 10)

38. scala> a.max

39. res50: Int = 10

40. //5.最小值

41. scala> val a = Array(4,1,2,4,10)

42. a: Array[Int] = Array(4, 1, 2, 4, 10)

43. scala> a.min

44. res51: Int = 1

45. //6.排序

46. scala> a.sorted

47. res53: Array[Int] = Array(1, 2, 4, 4, 10)

48. // 降序

49. scala> a.sorted.reverse

50. res56: Array[Int] = Array(10, 4, 4, 2, 1)

1.元组的使用详解

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

【1.语法格式】

• val/var 元组 = (元素1, 元素2, 元素3....)    //使用括号来定义元组

• val/var 元组 = 元素1-> 元素2   //使用‘’箭头’来定义元素（元组只有两个元素）

1. // 可以直接使用括号来定义一个元组

2. scala> val a = (1, "张三", 20, "北京市")

3. a: (Int, String, Int, String) = (1,张三,20,北京市)

4. //使用箭头,注意，这种元组只有两个元素

5. scala> val a = 1->5

6. a: (Int, Int) = (1,5)

7. scala> val z = "x"-> "y"

8. z: (String, String) = (x,y)

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

1. // 1.可以直接使用括号来定义一个元组

2. scala> val a = (1, "张三", 20, "北京市")

3. a: (Int, String, Int, String) = (1,张三,20,北京市)

4. // 2.获取第一个元素

5. scala> a._1

6. res57: Int = 1

7. // 3.获取第二个元素

8. scala> a._2

9. res58: String = 张三

10. // 4.不能修改元组中的值

11. scala> a._1 = 2

12. <console>:13: error: reassignment to val

13. a._1 = 2

14. ^

2.列表的使用详解

    List是scala中最重要的、也是最常用的数据结构。在scala中，也有两种列表，一种是不可变列表、另一种是可变列表。List具备以下性质：

• 可以保存重复的值

• 有先后顺序

2.1 不可变列表

不可变列表就是列表的元素、长度都是不可变的。
【1.语法格式】

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

2. val/var 变量名 = Nil   //使用 Nil 创建一个不可变的空列表

3. val/var 变量名 = 元素1 :: 元素2 :: Nil   //使用 :: 方法创建一个不可变列表

1. //方式1：使用 List(元素1, 元素2, 元素3, ...) 来创建一个不可变列表

2. scala> val a = List(1,2,3,4,5)

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

4. 
   

5. //方式2：使用Nil创建一个不可变的空列表

6. scala> val a = Nil

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

8. 
   

9. //方式3：使用 :: 方法创建列表，包含-2、-1,3三个元素

10. scala> val a = -2 :: -1::3 :: Nil

11. a: List[Int] = List(-2, -1, 3)

2.2 可变列表

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

要使用可变列表，先要导入 import scala.collection.mutable.ListBuffer
[尖叫提示]

• 可变集合都在 mutable 包中

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

【1.语法格式】

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

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

1. scala> val a = ListBuffer[Int]()

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

3. scala> val a = ListBuffer(1,2,3,4)

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

【2.可变列表的操作】

1. 获取元素（使用括号访问 (索引值) ）

2. 添加元素（ += ）

3. 追加一个列表（ ++= ）

4. 更改元素（ 使用括号获取元素，然后进行赋值 ）

5. 删除元素（ -= ）

6. 转换为List（ toList ）

7. 转换为Array（ toArray ）

1. // 导入不可变列表

2. scala> import scala.collection.mutable.ListBuffer

3. import scala.collection.mutable.ListBuffer

4. // 创建不可变列表

5. scala> val a = ListBuffer(1,2,3)

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

7. // 获取第一个元素

8. scala> a(0)

9. res19: Int = 1

10. 58

11. // 追加一个元素

12. scala> a += 4

13. res20: a.type = ListBuffer(1, 2, 3, 4)

14. // 追加一个列表

15. scala> a ++= List(5,6,7)

16. res21: a.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)

17. // 删除元素

18. scala> a -= 7

19. res22: a.type = ListBuffer(1, 2, 3, 4, 5, 6)

20. // 转换为不可变列表

21. scala> a.toList

22. res23: List[Int] = List(1, 2, 3, 4, 5, 6)

23. // 转换为数组

24. scala> a.toArray

25. res24: Array[Int] = Array(1, 2, 3, 4, 5, 6)

2.3 列表的常见操作（可变列表与不可变列表）

2.3.1 判断列表是否为空（ isEmpty ）

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

2. scala> val a = List(1,2,3,4)

3. a: List[Int] = List(1, 2, 3, 4)

4. 60

5. scala> a.length

6. res0: Int = 4

7. scala> a.isEmpty

8. res16: Boolean = false

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

2.3.2拼接两个列表（ ++ ）

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

2. scala> val a = List(1,2,3)

3. a: List[Int] = List(1, 2, 3)

4. scala> val b = List(4,5,6)

5. b: List[Int] = List(4, 5, 6)

6. scala> val c = a ++ b

7. c: List[Int] = List(1, 2, 3, 4, 5, 6)

2.3.3获取列表的首个元素（ head ）和剩余部分( tail )

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

2. 1. 使用head方法，获取列表的首个元素

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

4. scala> val a = List(1,2,3)

5. a: List[Int] = List(1, 2, 3)

6. scala> a.head

7. res4: Int = 1

8. scala> a.tail

9. res5: List[Int] = List(2, 3)

2.3.1反转列表（ reverse ）

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

2. scala> val a = List(1,2,3)

3. a: List[Int] = List(1, 2, 3)

4. scala> a.reverse

5. res6: List[Int] = List(3, 2, 1)

2.3.1获取前缀（ take ）、获取后缀（ drop ）

1. 示例5：获取列表的前缀、后缀以及使用take方法获取前n个元素

2. scala> val a = List(1,2,3,4,5)

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

4. // 获取列表a的前3个元素

5. scala> a.take(3)

6. res10: List[Int] = List(1, 2, 3)

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

8. scala> val a = List(1,2,3,4, 5)

9. a: List[Int] = List(1, 2, 3, 4, 5)

10. // 获取除了前3个元素以外的元素

11. scala> a.drop(3)

12. res11: List[Int] = List(4, 5)

2.3.1扁平化（ flaten ），因为列表数组之类的都可以嵌套的。

1. 示例6：扁平化操作，扁平化表示将列表中的列表中的所有元素放到一个列表中。使用flatten方法来进行扁平化

2. scala> val a = List(List(1,2), List(3), List(4,5))

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

4. 62

5. scala> a.flatten

6. res15: List[Int] = List(1, 2, 3, 4, 5)

2.3.1拉链（ zip ）和拉开（ unzip ）

1. 示例7：拉链与拉开

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

3. scala> val a = List("张三", "李四", "王五")

4. a: List[String] = List(张三, 李四, 王五)

5. scala> val b = List(19, 20, 21)

6. b: List[Int] = List(19, 20, 21)

7. scala> a.zip(b)

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

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

10. scala> res16.unzip

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

12. 转换字符串

2.3.1转换字符串（ toString ）

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

2. scala> val a = List(1,2,3,4)

3. a: List[Int] = List(1, 2, 3, 4)

4. scala> println(a.toString)

5. List(1, 2, 3, 4)

2.3.1生成字符串（ mkString ）

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

2. scala> a.mkString(",")

3. res20: String = 1,2,3,4

4. // 可以调用mkString的另一种重载方式，加上前缀和后缀

5. scala> a.mkString("[", ":", "]")

6. res22: String = [1:2:3:4]

2.3.1并集（ union ）

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

2. scala> val a1 = List(1,2,3,4)

3. a1: List[Int] = List(1, 2, 3, 4)

4. scala> val a2 = List(3,4,5,6)

5. a2: List[Int] = List(3, 4, 5, 6)

6. // 并集操作

7. scala> a1.union(a2)

8. res17: List[Int] = List(1, 2, 3, 4, 3, 4, 5, 6)

9. // 可以调用distinct去重

10. scala> a1.union(a2).distinct

11. res18: List[Int] = List(1, 2, 3, 4, 5, 6)

2.3.1交集（ intersect ）

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

2. scala> val a1 = List(1,2,3,4)

3. a1: List[Int] = List(1, 2, 3, 4)

4. scala> val a2 = List(3,4,5,6)

5. a2: List[Int] = List(3, 4, 5, 6)

6. scala> a1.intersect(a2)

7. res19: List[Int] = List(3, 4)

2.3.1差集（ diff ）

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

2. scala> val a1 = List(1,2,3,4)

3. a1: List[Int] = List(1, 2, 3, 4)

4. scala> val a2 = List(3,4,5,6)

5. a2: List[Int] = List(3, 4, 5, 6)

6. scala> a1.diff(a2)

7. res24: List[Int] = List(1, 2)

3.Set的使用

Set(集)是代表没有重复元素的集合。在Scala中集set也分可变和不可变两种。Set具备以下性质：

• 1. 元素不重复

• 2. 不保证插入顺序

3.1 不可变集set

【1.语法格式】

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

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

【2.set的操作】

1. 获取集的大小（ size ）

2. 遍历集（ 和遍历数组一致 ）

3. 添加一个元素，生成一个Set（ + ）

4. 拼接两个集，生成一个Set（ ++ ）

5. 拼接集和列表，生成一个Set（ ++ ）

1. // 创建集

2. scala> val a = Set(1,1,2,3,4,5)

3. a: scala.collection.immutable.Set[Int] = Set(5, 1, 2, 3, 4)

4. // 获取集的大小

5. scala> a.size

6. res0: Int = 5

7. // 遍历集

8. scala> for(i <- a) println(i)

9. // 删除一个元素

10. scala> a - 1

11. res5: scala.collection.immutable.Set[Int] = Set(5, 2, 3, 4)

12. // 拼接两个集

13. scala> a ++ Set(6,7,8)

14. res2: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 7, 3, 8, 4)

15. // 拼接集和列表

16. scala> a ++ List(6,7,8,9)

17. res6: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

3.2 可变集set

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

1. scala> val a = Set(1,2,3,4)

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

3. // 添加元素

4. scala> a += 5

5. res25: a.type = Set(1, 5, 2, 3, 4)

6. // 删除元素

7. scala> a -= 1

8. res26: a.type = Set(5, 2, 3, 4)

4.Map映射的使用

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

4.1 不可变Map

【语法结构】

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

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

1. scala> val map = Map("zhangsan"->30, "lisi"->40)

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

3. scala> val map = Map(("zhangsan", 30), ("lisi", 30))

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

5. // 根据key获取value

6. scala> map("zhangsan")

7. res10: Int = 30

4.2可变Map

可变Map需要手动导入 import scala.collection.mutable.Map 。定义语法与不可变Map一致

1. scala> import scala.collection.mutable.Map

2. import scala.collection.mutable.Map

3. scala> val map = Map("zhangsan"->30, "lisi"->40)

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

5. // 修改value

6. scala> map("zhangsan") = 20

4.3 Map的操作（可变Map与不可变Map）

1. Map基本操作

2. 获取值( map(key) )

3. 获取所有key（ map.keys ）

4. 获取所有value（ map.values ）

5. 遍历map集合

6. getOrElse

7. 增加key,value对

8. 删除key

1. scala> val map = Map("zhangsan"->30, "lisi"->40)

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

3. // 获取zhagnsan的年龄

4. scala> map("zhangsan")

5. res10: Int = 30

6. // 获取所有的学生姓名

7. scala> map.keys

8. res13: Iterable[String] = Set(lisi, zhangsan)

9. // 获取所有的学生年龄

10. scala> map.values

11. res14: Iterable[Int] = HashMap(40, 30)

12. // 打印所有的学生姓名和年龄

13. scala> for((x,y) <- map) println(s"$x $y")

14. lisi 40

15. zhangsan 30

16. // 获取wangwu的年龄，如果wangwu不存在，则返回-1

17. scala> map.getOrElse("wangwu", -1)

18. res17: Int = -1

19. // 新增一个学生：wangwu, 35

20. scala> map + "wangwu"->35

21. res22: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30, wangw

22. u -> 35)

23. // 将lisi从可变映射中移除

24. scala> map - "lisi"

25. res23: scala.collection.mutable.Map[String,Int] = Map(zhangsan -> 30)

作者：涤生手记

链接：https://blog.csdn.net/qq_26442553/article/details/108342680

来源：CSDN
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。