Scala之数组、元组、映射Map、Set集合和List列表

目录

1. 数组

2. 元组

3. 映射Map

4. Set集合

5. 列表 List

---

1. 数组

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

1.1 定长数组

• 定长数组指的是数组的长度是不允许改变的；
• 数组的元素是可以改变的；
• 语法：

// 通过指定长度定义数组
val/var 变量名 = new Array[元素类型](数组长度)
// 用元素直接初始化数组
val/var 变量名 = Array(元素1, 元素2, 元素3...)

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

scala> a(0)
res19: Int = 0

scala> a(10)
java.lang.ArrayIndexOutOfBoundsException: 10
  ... 32 elided

scala> a.length
res16: Int = 10

• 注意
  • 在scala中，数组的泛型使用[]来指定；
  • 使用()来获取元素。

1.2 变长数组

• 变长数组指的是数组的长度是可变的，可以往数组中添加、删除元素；
• 创建变长数组，需要提前导入ArrayBuffer类。

import scala.collection.mutable.ArrayBuffer

• 语法
  • 创建空的ArrayBuffer变长数组

val/var a = ArrayBuffer[元素类型]()

• 创建带有初始元素的ArrayBuffer

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

如：

//导入ArrayBuffer类型
scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

//定义一个长度为0的整型变长数组
scala> val a = ArrayBuffer[Int]()
a: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

//定义一个有初始元素的变长数组
scala> val b = ArrayBuffer("hadoop", "storm", "spark")
b: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(hadoop, storm, spark)

• 变长数组的增删改操作：
  • 使用+=添加元素；
  • 使用-=删除元素；
  • 使用++=追加一个数组到变长数组。

// 追加一个元素
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)

1.3 遍历数组

• 可以使用以下两种方式来遍历数组：（实质上都是for循环）
  • 使用for表达式 直接遍历数组中的元素；
  • 使用 索引 获得数组中的元素。

scala> for(i <- a) println(i)
hadoop
hive
flume
spark

//0 to n    ——包含0，也包含n
scala> for(i <- 0 to a.length -1 ) println(a(i))
hadoop
hive
flume
spark

//0 until n ——生成一系列的数字，包含0，不包含n
scala> for(i <- 0 until a.length) println(a(i))
hadoop
hive
flume
spark

1.4 数组常用操作

• scala中的数组封装了丰富的计算操作，将来在对数据处理的时候，不需要我们自己再重新实现。
  • 求和——sum方法
  • 求最大值——max方法
  • 求最小值——min方法
  • 排序——sorted方法

//先定义一个数组

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

//求和
scala> array.sum
res10: Int = 15

//求最大值
scala> array.max
res11: Int = 5

//求最小值
scala> array.min
res12: Int = 1

//升序 sorted原数组不变，生成一个新的排过序的数组
scala> array.sorted
res13: Array[Int] = Array(1, 2, 3, 4, 5)

//降序    reverse 反转（必须先排序，再反转）
scala> array.sorted.reverse
res14: Array[Int] = Array(5, 4, 3, 2, 1)

2. 元组

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

2.1 定义元组

• （1）使用括号来定义元组。

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

scala> val a = (1, "张三", 20, "北京市")
a: (Int, String, Int, String) = (1,张三,20,北京市)

• （2）使用箭头来定义元素（元组只有两个元素）

val/var 元组 = 元素1 -> 元素2
scala> val b = 1 -> 2 
b: (Int, Int) = (1,2)

2.2 访问元组

• 使用 _1、_2、_3....来访问元组中的元素；
• 元组的index从1开始，_1表示访问第一个元素，依次类推。

//获取元组中的第一个元素
scala> a._1
res18: Int = 1

//获取元组中的第二个元素
scala> a._2
res19: String = 张三

//不能修改元组中的值
scala> a._4 = "上海"
<console>:12: error: reassignment to val
       a._4="上海"

3. 映射Map

• Map可以称之为映射。它是由键值对组成的集合。scala当中的Map集合与java当中的Map类似，也是key，value对形式的。
• 在scala中，Map也分为不可变Map和可变 Map。

3.1 不可变Map

• 定义语法

（1）val/var map = Map(键->值, 键->值, 键->值...)    // 推荐这种写法，可读性更好

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

// 根据key获取value
scala> map1("zhangsan")
res10: Int = 30
（2）val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)...)

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

13.2 可变Map

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

//导包
scala> import scala.collection.mutable.Map
import scala.collection.mutable.Map

//定义可变的map
scala> val map3 = Map("zhangsan"->30, "lisi"->40)
map3: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 30)

//获取zhangsan这个key对应的value
scala> map3("zhangsan")
res26: Int = 30

//给zhangsan这个key重新赋值value
scala> map3("zhangsan") = 50

//显示map3
scala> map3
res28: scala.collection.mutable.Map[String,Int] = Map(lisi -> 40, zhangsan -> 50)

3.3 Map基本操作

（1）按照key获取value

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

// 获取wangwu的年龄，如果wangwu不存在，则返回-1 比较友好，避免遇到不存在的key而报错
scala> map.getOrElse("wangwu", -1)
res11: Int = -1

（2）修改key对应的value

scala> map("lisi") = 50

（3）添加key-value键值对

scala> map += ("wangwu" ->35)
res12: map.type = Map(lisi -> 50, zhangsan -> 30, wangwu -> 35)

（4）删除key-value键值对

scala> map -= "wangwu"
res13: map.type = Map(lisi -> 50, zhangsan -> 30)

（5）获取所有的key（两种方式）

//获取所有的key
scala> map.keys
res36: Iterable[String] = Set(lisi, zhangsan)

//获取所有的key
scala> map.keySet
res37: scala.collection.Set[String] = Set(lisi, zhangsan)

（6）获取所有的value

//获取所有的value
scala> map.values
res38: Iterable[Int] = HashMap(50, 30)

（7）遍历map（三种方式）

//第一种遍历：先获取key，再根据key来获取值
scala> for(k <- map.keys) println(k + " -> " + map(k))
lisi -> 50
zhangsan -> 30

//第二种：直接获取kv，作为一个元组，直接遍历map（再获取元组中第一个元素，第二个元素的值）
scala> for(kv <- map) println(kv._1 + "->" + kv._2)

//第三种遍历：直接将k，v解析出来
scala> for((k, v) <- map) println(k + " -> " + v)
lisi -> 50
zhangsan -> 30

4. Set集合

• Set是代表没有重复元素的集合。
• Set具备以下性质：
  • 元素不重复；
  • 不保证插入顺序（无序）。
• scala中的set集合也分为两种，一种是不可变集合，另一种是可变集合。

4.1 不可变Set集合

• 语法

（1）创建一个空的不可变集
val/var 变量名 = Set[类型]()
scala> val set1 = Set[Int]()
set1: scala.collection.immutable.Set[Int] = Set()

（2）给定元素来创建一个不可变集
val/var 变量名 = Set[类型](元素1, 元素2, 元素3...)

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

对不可变集合set的操作：

（1）获取集合的大小
scala> a.size 
res0: Int = 5

（2）遍历集合
scala> for(i <- a) println(i)

（3）添加元素生成新的集合
scala> a + 6
res1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)

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

（5）删除set集合中存在的元素
scala> a -- Set(2,3)
res3: scala.collection.immutable.Set[Int] = Set(5, 1, 4)

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

（7）求2个Set集合的交集
scala> a & Set(3,4,5,6)
res5: scala.collection.immutable.Set[Int] = Set(5, 3, 4)

注意：对不可变的set集合进行添加删除等操作，原集合并没有发生任何变化；

而是生成了新的集合，新的集合相比于原来的集合来说发生了变化。

4.2 可变Set集合

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

（1）导包
scala> import scala.collection.mutable.Set
import scala.collection.mutable.Set

（2）定义可变的set集合
scala> val set = Set(1, 2, 3, 4, 5)
set: scala.collection.mutable.Set[Int] = Set(1, 5, 2, 3, 4)

（3）添加单个元素
scala> set += 6
res10: set.type = Set(1, 5, 2, 6, 3, 4)

（4）添加多个元素
scala> set += (6, 7, 8, 9)
res11: set.type = Set(9, 1, 5, 2, 6, 3, 7, 4, 8)

（5）添加一个set集合中的元素
scala> set ++= Set(10, 11)
res12: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 11, 8)

（6）删除一个元素
scala> set -= 11
res13: set.type = Set(9, 1, 5, 2, 6, 3, 10, 7, 4, 8)

（7）删除多个元素
scala> set -= (9, 10)
res15: set.type = Set(1, 5, 2, 6, 3, 7, 4, 8)

（8）删除一个set子集
scala> set --= Set(7, 8)
res19: set.type = Set(1,5, 2, 6, 3, 4)

（9）删除一个元素
scala> set.remove(1)
res17: Boolean = true

（10）查看集合元素
scala> set
res18: scala.collection.mutable.Set[Int] = Set(5, 2, 6, 3, 4)

5. 列表 List

• List是scala中最重要的、也是最常用的数据结构。
• List具备以下性质：
  • 可以保存重复的值（可重复）；
  • 有先后顺序（有序）；
• 在scala中，也有两种列表，一种是不可变列表、另一种是可变列表。

5.1 不可变列表

• 不可变列表就是列表的元素、长度都是不可变的。
• 语法
  • 使用 List(元素1, 元素2, 元素3, ...) 来创建一个不可变列表，语法格式有如下三种：

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

//创建一个不可变列表，存放以下几个元素（1,2,3,4）
scala> val list1 = List(1, 2, 3, 4)
list1: List[Int] = List(1, 2, 3, 4)

（2）val/var 变量名 = Nil

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

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

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

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

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

5.2 可变列表

• 可变列表就是列表的元素、长度都是可变的。
• 要使用可变列表，先要导入 import scala.collection.mutable.ListBuffer。
• 语法有如下两种：

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

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

//如：定义一个空的可变列表
scala> val a = ListBuffer[Int]()
a: scala.collection.mutable.ListBuffer[Int] = ListBuffer()

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

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

//定义一个有初始元素的可变列表
scala> val b = ListBuffer(1, 2, 3, 4)
b: scala.collection.mutable.ListBuffer[Int] = ListBuffer(1, 2, 3, 4)

5.3 列表操作

（1）获取第一个元素（2种方式）
scala> list(0)
res4: Int = 1
//或
scala> list.head
res5: Int = 1

（2）获取除了第一个元素外其他元素组成的列表
scala> list.tail
res6: scala.collection.mutable.ListBuffer[Int] = ListBuffer(2, 3, 4)

（3）添加单个元素
scala> list += 5
res7: list.type = ListBuffer(1, 2, 3, 4, 5)

（4）添加一个不可变的列表
scala> list ++= List(6, 7)
res8: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7)

（5）添加一个可变的列表
scala> list ++= ListBuffer(8, 9)
res9: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8, 9)

（6）删除单个元素
scala> list -= 9
res10: list.type = ListBuffer(1, 2, 3, 4, 5, 6, 7, 8)

（7）删除一个不可变的列表存在的元素
scala> list --= List(7,8)
res11: list.type = ListBuffer(1, 2, 3, 4, 5, 6)

（8）删除一个可变的列表存在的元素
scala> list --= ListBuffer(5,6)
res12: list.type = ListBuffer(1, 2, 3, 4)

（9）toList根据可变的列表生成一个不可变列表，原列表不变
scala> list.toList
res13: List[Int] = List(1, 2, 3, 4)

（10）toArray根据可变的列表生成一个新的不可变数组，原列表不变
scala> list.toArray
res14: Array[Int] = Array(1, 2, 3, 4)