Scala中的集【Set】、映射【Map】、迭代器【iterator】

---

Java集合框架
如果有Java基础，建议好好理解Java的集合框架和泛型，下文中Scala的集很简单，死噶啦！！！

集

概述：

Set(也叫: 集)代表没有重复元素的集合。

特点：

唯一、无序

解释：

• 1.唯一 的意思是 Set中的元素具有唯一性，没有重复元素。
• 2.无序 的意思是 Set集中的元素，添加顺序和取出顺序不一致。

Scala中的集分为俩种，一种是不可变集，另一种是可变集。

---

不可变集

不可变集指的是元素，集的长度都不可变。

语法：

• 格式一: 创建一个空的不可变集
  • val/var 变量名 = Set[类型]()
• 格式二: 给定元素来创建一个不可变集
  • val/var 变量名 = Set(元素1, 元素2, 元素3…)

代码实例：

1. 定义一个空的整型不可变集.
2. 定义一个不可变集，保存以下元素：1,1,3,2,4,8.
3. 打印结果.

object 集的定义 {
    
    

  def main(args: Array[String]): Unit = {
    
    
    //1. 定义一个空的整型不可变集.
    val set1 = Set[Int]()
    //2. 定义一个不可变集，保存以下元素：1,1,3,2,4,8.
    val set2 = Set(1, 1, 3, 2, 4, 8)
    //3. 打印结果
    println(s"set1: ${set1}")
    println(s"set2: ${set2}")
  }

}

set1: Set()
set2: Set(1, 2, 3, 8, 4)

---

不可变集的常用操作

• 1.获取集的大小（ size ）
• 2.遍历集（ 和遍历数组一致 ）
• 3.添加一个元素，生成一个新的Set（ + ）
• 4.拼接两个集，生成一个新的Set（ ++ ）
• 5.拼接集和列表，生成一个新的Set（ ++ ）

注意：

• 1.-(减号) 表示删除一个元素, 生成一个新的Set
• 2.-- 表示批量删除某个集中的元素, 从而生成一个新的Set

代码实例：

1. 创建一个集，包含以下元素：1,1,2,3,4,5
2. 获取集的大小, 并打印结果.
3. 遍历集，打印每个元素.
4. 删除元素1，生成新的集, 并打印.
5. 拼接另一个集Set(6, 7, 8), 生成新的集, 并打印.
6. 拼接一个列表List(6,7,8, 9), 生成新的集, 并打印.

object 集的常用操作 {
    
    

  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)
    //6. 拼接一个列表(6,7,8, 9)
    val set4 = set1 ++ List(6, 7, 8, 9)
    println("set4: " + set4)
  }

}

set1的长度为：5
set1集中的元素为: 
5
1
2
3
4
---------------
set2: Set(5, 2, 3, 4)
set4: Set(5, 1, 6, 9, 2, 7, 3, 8, 4)

---

---

可变集

概述：

可变集指的是元素, 集的长度都可变, 它的创建方式和不可变集的创建方式一致，只不过需要先导入可变集类。

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

代码示例：

1. 定义一个可变集，包含以下元素: 1,2,3, 4
2. 添加元素5到可变集中
3. 添加元素6, 7, 8到可变集中
4. 从可变集中移除元素1 5. 从可变集中移除元素3, 5, 7
5. 打印结果

object 可变集 {
    
    

  def main(args: Array[String]): Unit = {
    
    
    //1. 定义一个可变集，包含以下元素: 1,2,3, 4
    var set1 = Set(1, 2, 3, 4)
    set1 += 5
    //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)
  }

}

Set(6, 2, 8, 4)

---

---

映射

映射指的就是Map。它是由键值对(key, value)组成的集合。

特点：

• 键具有唯一性, 但是值可以重复。
• 注意：如果添加重复元素(即: 两组元素的键相同), 则 会用新值覆盖旧值 .

在Scala中，Map也分为不可变Map和可变Map。

---

不可变Map

不可变Map指的是元素，长度都不可变。

语法：

• 方式一: 通过 箭头 的方式实现.
  • val/var map = Map(键->值, 键->值, 键->值…) // 推荐，可读性更好
• 方式二: 通过 小括号 的方式实现.
  • val/var map = Map((键, 值), (键, 值), (键, 值), (键, 值)…)

代码实例：

1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24, 李四 -> 40
2. 打印结果.

object 不可变映射 {
    
    

  def main(args: Array[String]): Unit = {
    
    
    //1. 定义一个映射，包含以下学生姓名和年龄数据.
    val map1 = Map("张三" -> 23, "李四" -> 24, "李四" -> 40)
    val map2 = Map(("张三", 23), ("李四", 24), ("李四", 40))
    //2. 打印结果.
    println(s"map1: ${map1}")
    println(s"map2: ${map2}")
  }

}

map1: Map(张三 -> 23, 李四 -> 40)
map2: Map(张三 -> 23, 李四 -> 40)

---

可变Map

可变Map指的是元素，长度都可变，定义语法与不可变Map一致，只不过需要先手动导包。

• import scala.collection.mutable.Map

代码实例：

1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
2. 修改张三的年龄为30
3. 打印结果

import scala.collection.mutable.Map

object 可变映射 {
    
    

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

}

map1: Map(张三 -> 30, 李四 -> 24)
map2: Map(张三 -> 23, 李四 -> 24)

---

Map基本操作

1. map(key) : 根据键获取其对应的值, 键不存在返回None.
2. map.keys : 获取所有的键.
3. map.values : 获取所有的值.
4. 遍历map集合: 可以通过普通for实现.
5. getOrElse: 根据键获取其对应的值, 如果键不存在, 则返回指定的默认值.
6. +号 : 增加键值对, 并生成一个新的Map.
   注意: 如果是可变Map, 则可以通过 +=或者++= 直接往该可变Map中添加键值对元素.
7. -号 : 根据键删除其对应的键值对元素, 并生成一个新的Map.
   注意: 如果是可变Map, 则可以通过 -=或者–= 直接从该可变Map中删除键值对元素

代码实例：

1. 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
2. 获取张三的年龄, 并打印.
3. 获取所有的学生姓名, 并打印.
4. 获取所有的学生年龄, 并打印.
5. 打印所有的学生姓名和年龄.
6. 获取 王五 的年龄，如果 王五 不存在，则返回-1, 并打印.
7. 新增一个学生：王五, 25, 并打印结果.
8. 将 李四 从可变映射中移除, 并打印

import scala.collection.mutable.Map

object 可变映射常用操作 {
    
    

  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, 并打印结果.
    map1 += ("王五" -> 25)
    //8. 将`李四`从可变映射中移除, 并打印.
    map1 -= "李四"
    println(s"map1: ${map1}")
  }

}

Some(23)
Set(张三, 李四)
HashMap(23, 24)
键:张三, 值:23
键:李四, 值:24
---------------
-1
---------------
map1: Map(王五 -> 25, 张三 -> 23)

Process finished with exit code 0

---

---

迭代器

概述：
Scala针对每一类集合都提供了一个迭代器(iterator), 用来迭代访问集合. 作用和Java中基本一样，同样是为了访问集合，而且很多方法非常相似。

Java中的集合框架

注意事项：

• 1.使用 iterator 方法可以从集合获取一个迭代器。
  • 迭代器中有俩个方法：
    • hasNext方法: 查询容器中是否有下一个元素
    • next方法: 返回迭代器的下一个元素，如果没有，抛出NoSuchElementException
• 2.每一个迭代器都是有状态的。
  • 即：迭代完后保留在最后一个元素的位置，再次使用则抛出NoSuchElementException
• 3.可以使用while或者for来逐个获取元素。

代码实例：

1. 定义一个列表，包含以下元素：1,2,3,4,5
2. 使用while循环和迭代器，遍历打印该列表

object 迭代器的使用 {
    
    

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

}

1
2
3
4
5
---------------
Exception in thread "main" java.util.NoSuchElementException: next on empty iterator
	at scala.collection.Iterator$$anon$2.next(Iterator.scala:39)
	at scala.collection.Iterator$$anon$2.next(Iterator.scala:37)
	at scala.collection.LinearSeqLike$$anon$1.next(LinearSeqLike.scala:47)
	at cn.dongkaizi.迭代器.迭代器的使用$.main(迭代器的使用.scala:20)
	at cn.dongkaizi.迭代器.迭代器的使用.main(迭代器的使用.scala)