Scala集合

1.数组

1.1定长数组

创建数组

语法

格式一 : 通过指定长度定义数组

val /var 变量名 = new Array[元素类型](数组长度)

格式二 : 通过指定元素定义数组

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

注意

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

使用 数组名 (索引) 来获取数组中的元素.

数组元素是有默认值的, Int:0, Double:0.0, String: null

通过 数组名 .length 或者 数组名 .size 来获取数组的长度.

1.2变长数组

数组的长度和内容都是可变的，可以往数组中添加、删除元素

语法

创建变长数组，需要先导入 ArrayBuffer类.

import scala.collection.mutable.ArrayBuffer

格式一 : 创建空的ArrayBuffer变长数组

val /var 变量名 = ArrayBuffer[元素类型]()

格式二 : 创建带有初始元素的ArrayBuffer变长数组

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

增删改元素

语法

使用 += 添加单个元素

使用 - = 删除单个元素

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

使用 -- = 移除变长数组中的指定多个元素

1.3遍历数组

// 案例: 遍历数组
object ClassDemo04 {
 def main(args: Array[String]): Unit = {
  //1. 定义一个数组，包含以下元素1,2,3,4,5
  val arr = Array(1, 2, 3, 4, 5)
  //2. 通过两种遍历方式遍历数组，并打印数组中的元素.
  //方式一: 遍历索引的形式实现.
  for(i <- 0 to arr.length -1) println(arr(i))
  println("-" * 15)  //分割线
  for(i <- 0 until arr.length) println(arr(i))
  println("-" * 15)  //分割线
  //方式二: 直接遍历数组元素.
  for(i <- arr) println(i)
}
}

1.4常用方法

sum() 方法: 求和

max() 方法: 求最大值

min() 方法: 求最小值

sorted() 方法: 排序, 返回一个新的数组

reverse() 方法: 反转, 返回一个新的数组

2.元组

元组一般用来存储多个不同类型的值。例如同时存储姓名，年龄，性别，出生年月这些数据, 就要用到元组来存储了。并且元组的长度和元素都是不可变的。

创建语法

格式一 : 通过小括号实现

val /var 元组 = (元素1, 元素2, 元素3....)

格式二 : 通过箭头来实现

val /var 元组 = 元素1->元素2

注意: 上述这种方式, 只适用于元组中只有两个元素的情况.

访问元组中的元素

格式一 : 访问元组中的单个元组.

println (元组名._1) //打印元组的第一个元素.
println(元组名._2) //打印元组的第二个元组.

格式二 : 遍历元组

val tuple1 = (值1, 值2, 值3, 值4, 值5...) //可以有多个值
val it = tuple1.productIterator   //获取当前元组的迭代器对象
for(i <- it) println(i) //打印元组中的所有内容.

3.列表

列表(List)是Scala中最重要的, 也是最常用的一种数据结构。它存储的数据, 特点是: 有序, 可重复.
在Scala中，列表分为两种, 即: 不可变列表和可变列表.

3.1不可变列表

语法格式

格式一

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

格式二

val /var 变量名 = Nil

格式三 : 使用 :: 方法实现.

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

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

3.2可变列表

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

要使用可变列表 , 必须先导包

import scala.collection.mutable.ListBuffer

格式一 : 创建空的可变列表

val /var 变量名 = ListBuffer[数据类型]()

格式二 : 通过 小括号 直接初始化.

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

3.3常见操作

列表名(索引) 根据索引(索引从0开始),获取列表中的指定元素.

列表名(索引)=值 修改元素值

+= 往列表中添加单个元素

++= 往列表中追加一个列表

-= 删除列表中的某个指定元素

--= 以列表的形式,删除列表中的多个元素.

toList 将可变列表(ListBuffer)转换为不可变列表(List)

toArray 将可变列表(ListBuffer)转换为数组

案例

 //2. 获取第一个元素, 并打印结果到控制台.
  println(list1(0))
  //3. 添加一个新的元素：4
  list1 += 4
  //4. 追加一个列表，该列表包含以下元素：5,6,7
  list1 ++= List(5, 6, 7)
  //5. 删除元素7
  list1 -= 7
  //6. 删除元素3, 4
  list1 --= List(3, 4)
  //7. 将可变列表转换为不可变列表
  val list2 = list1.toList
  //8. 将可变列表转换为数组
  val arr = list1.toArray
  //9. 打印结果.
  println(s"list1: ${list1}")
  println(s"list2: ${list2}")
  println(s"arr: ${arr}")

3.4列表的常用操作

isEmpty 判断列表是否为空

++ 拼接两个列表,返回一个新的列表

head 获取列表的首个元素

tail 获取列表中除首个元素之外,其他所有的元素

reverse 对列表进行反转,返回一个新的列表

take 获取列表中的前缀元素(具体个数可以自定义)

drop 获取列表中的后缀元素(具体个数可以自定义)

flatten 对列表进行扁平化操作,返回一个新的列表

zip 对列表进行拉链操作,即:将两个列表合并成一个列表

unzip 对列表进行拉开操作,即:将一个列表拆解成两个列表

toString 将列表转换成其对应的默认字符串形式

mkString 将列表转换成其对应的指定字符串形式

union 获取两个列表的并集元素,并返回一个新的列表

intersect 获取两个列表的交集元素,并返回一个新的列表

diff 获取两个列表的差集元素,并返回一个新的列表

案例

def main(args: Array[String]): Unit = {
  //1. 定义一个列表list1，包含以下元素：1,2,3,4
  val list1 = List(1, 2, 3, 4)
  //2. 使用isEmpty方法判断列表是否为空, 并打印结果.
  println(s"isEmpty: ${list1.isEmpty}")
   //3. 再定义一个列表list2，包含以下元素: 4,5,6
  val list2 = List(4, 5, 6)
  //4. 使用`++`将两个列表拼接起来, 并打印结果.
  val list3 = list1 ++ list2
  println(s"list3: ${list3}")
  //5. 使用head方法，获取列表的首个元素, 并打印结果.
  println(s"head: ${list3.head}")
  //6. 使用tail方法，获取列表中除首个元素之外, 其他所有的元素, 并打印结果.
  println(s"tail: ${list3.tail}")
  //7. 使用reverse方法将列表的元素反转, 并打印反转后的结果.
  val list4 = list3.reverse
  println(s"list4: ${list4}")
  //8. 使用take方法获取列表的前缀元素(前三个元素), 并打印结果.
  println(s"take: ${list3.take(3)}")
  //9. 使用drop方法获取列表的后缀元素(除前三个以外的元素), 并打印结果.
  println(s"drop: ${list3.drop(3)}")
}

3.5嵌套列表

如果某个列表中的所有元素都是列表, 那么这样的列表就称之为: 嵌套列表.

扁平化表示将嵌套列表中的所有具体元素单独的放到一个新列表中.

 def main(args: Array[String]): Unit = {
  //1. 定义一个列表, 该列表有三个元素, 分别为：List(1,2)、List(3)、List(4,5)
  val list1 = List(List(1,2), List(3), List(4, 5))
  //2. 使用flatten将这个列表转换为List(1,2,3,4,5)
  val list2 = list1.flatten
  //3. 打印结果
  println(list2)

3.6拉链与拉开

 def main(args: Array[String]): Unit = {
  //1. 定义列表names, 保存三个学生的姓名，分别为：张三、李四、王五
  val names = List("张三", "李四", "王五")
  //2. 定义列表ages, 保存三个学生的年龄，分别为：23, 24, 25
  val ages = List(23, 24, 25)
  //3. 使用zip将列表names和ages, 组合成一个元素为元组的列表list1.
  val list1 = names.zip(ages)
  //4. 使用unzip将列表list1拆解成包含两个列表的元组tuple1
  val tuple1 = list1.unzip
  //5. 打印结果
  println("拉链: "+ list1)
  println("拉开: " + tuple1)
}

结果

拉链: List((张三,23), (李四,24), (王五,25))

拉开: (List(张三, 李四, 王五),List(23, 24, 25))

3.7列表转字符串

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

mkString 方法: 可以将元素以指定分隔符拼接起来。

3.8并集, 交集, 差集**

union: 表示对两个列表取并集，而且不去重

例如: list1.union(list2), 表示获取list1和list2中所有的元素(元素不去重).

如果想要去除重复元素, 则可以通过 distinct 实现.

intersect: 表示对两个列表取交集

例如: list1.intersect(list2), 表示获取list1, list2中都有的元素.

diff: 表示对两个列表取差集.

例如：list1.diff(list2)，表示获取list1中有, 但是list2中没有的元素

4.集

Set(也叫: 集)代表没有重复元素的集合。特点是: 唯一, 无序。Scala中的集分为两种，一种是不可变集，另一种是可变集

4.1不可变集

不可变集指的是元素, 集的长度都不可变.

语法

格式一 : 创建一个空的不可变集

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

格式二 : 给定元素来创建一个不可变集

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

不可变集的常见操作

获取集的大小（ size ）

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

添加一个元素，生成一个新的Set（ + ）

拼接两个集，生成一个新的Set（ ++ ）

拼接集和列表，生成一个新的Set（ ++ ）

def main(args: Array[String]): Unit = {
  //1. 创建一个集，包含以下元素：1,1,2,3,4,5
  val set1 = Set(1, 1, 2, 3, 4, 5)
  //2. 获取集的大小
  println("set1的长度为: " + set1.size)
  //3. 遍历集，打印每个元素
  println("set1集中的元素为: ")
  for(i <- set1) println(i)
  println("-" * 15)
  //4. 删除元素1，生成新的集
   val set2 = set1 - 1
  println("set2: " + set2)
  //5. 拼接另一个集（6, 7, 8)
  val set3 = set1 ++ Set(6, 7, 8)
  println("set3: " + set3)
  //6. 拼接一个列表(6,7,8, 9)
  val set4 = set1 ++ List(6, 7, 8, 9)
  println("set4: " + set4)
}

4.2可变集

手动导入：import scala.collection.mutable.Set

案例

def main(args: Array[String]): Unit = {
  //1. 定义一个可变集，包含以下元素: 1,2,3, 4
  val set1 = Set(1, 2, 3, 4)
  //2. 添加元素5到可变集中
  set1 += 5
  //3. 添加元素6, 7, 8到可变集中
  //set1 ++= Set(6, 7, 8)
  set1 ++= List(6, 7, 8)    //两种写法均可.
  //4. 从可变集中移除元素1
  set1 -= 1
  //5. 从可变集中移除元素3, 5, 7
  //set1 --= Set(3, 5, 7)
  set1 --= List(3, 5, 7)    //两种写法均可.
  //6. 打印结果.
  println(set1)
}

5.映射

映射指的就是Map。它是由键值对(key, value)组成的集合。特点是: 键具有唯一性, 但是值可以重复. 在Scala中，Map也分为不可变Map和可变Map。

5.1不可变Map

创建语法

方式一 : 通过 箭头 的方式实现

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

方式二 : 通过 小括号 的方式实现

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

5.2可变Map

手动导包:

import scala.collection.mutable.Map

案例

import scala.collection.mutable.Map
//案例: 演示可变Map.
object ClassDemo20 {
 def main(args: Array[String]): Unit = {
  //1. 定义一个映射，包含以下学生姓名和年龄数据.
  val map1 = Map("张三" -> 23, "李四" -> 24)
  val map2 = Map(("张三", 23),("李四", 24))
  //2. 修改张三的年龄为30
  map1("张三") = 30
  //3. 打印结果
  println(s"map1: ${map1}")
  println(s"map2: ${map2}")
}
}

5.3Map基本操作

map(key) : 根据键获取其对应的值, 键不存在返回None.

map.keys : 获取所有的键.

map.values : 获取所有的值.

遍历map集合: 可以通过普通for实现.

getOrElse: 根据键获取其对应的值, 如果键不存在, 则返回指定的默认值.

+号 : 增加键值对, 并生成一个新的Map.
注意: 如果是可变Map, 则可以通过 += 或者++= 直接往该可变Map中添加键值对元素.

-号 : 根据键删除其对应的键值对元素, 并生成一个新的Map.
注意: 如果是可变Map, 则可以通过 - =或者--= 直接从该可变Map中删除键值对元素.

案例

def main(args: Array[String]): Unit = {
  //1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
  val map1 = Map("张三" -> 23, "李四" -> 24)
  //2. 获取张三的年龄, 并打印.
  println(map1.get("张三"))
  //3. 获取所有的学生姓名, 并打印.
  println(map1.keys)
  //4. 获取所有的学生年龄, 并打印.
  println(map1.values)
  //5. 打印所有的学生姓名和年龄.
  for((k, v) <- map1) println(s"键:${k}, 值:${v}")
  println("-" * 15)
  //6. 获取`王五`的年龄，如果`王五`不存在，则返回-1, 并打印.
  println(map1.getOrElse("王五", -1))
  println("-" * 15)
  //7. 新增一个学生：王五, 25, 并打印结果.
  /*//不可变Map
  val map2 = map1 + ("王五" -> 25)
  println(s"map1: ${map1}")
  println(s"map2: ${map2}")*/
  map1 += ("王五" -> 25)
  //8. 将`李四`从可变映射中移除, 并打印.
  map1 -= "李四"
  println(s"map1: ${map1}")
}

6.迭代器

Scala针对每一类集合都提供了一个迭代器(iterator), 用来迭代访问集合.

使用 iterator 方法可以从集合获取一个迭代器.

迭代器中有两个方法:

hasNext 方法: 查询容器中是否有下一个元素

next 方法: 返回迭代器的下一个元素，如果没有，抛出NoSuchElementException

每一个迭代器都是有状态的

即: 迭代完后保留在最后一个元素的位置. 再次使用则抛出NoSuchElementException

可以使用while或者for来逐个获取元素.

案例

def main(args: Array[String]): Unit = {
  //1. 定义一个列表，包含以下元素：1,2,3,4,5
  val list1 = List(1, 2, 3, 4, 5)
  //2. 使用while循环和迭代器，遍历打印该列表.
  //2.1 根据列表获取其对应的迭代器对象.
  val it = list1.iterator
  //2.2 判断迭代器中是否有下一个元素.
  while(it.hasNext){
   //2.3 如果有, 则获取下一个元素, 并打印.
   println(it.next)
 }
  
  //分割线.
  println("-" * 15)
  //迭代完后, 再次使用该迭代器获取元素, 则抛异常: NoSuchElementException
  println(it.next)
}