★ Scala ★ —— 数据结构（集、映射、迭代器）

忘是亡心i 2022-10-29 12:27 208阅读 0赞

### 数据结构（集、映射、迭代器） ###

*   *  集
     *   *  1.1 概述
         *  1.2 不可变集
         *  1.3 可变集
         *   *  1.3.1概述
         *  1.4 不可变集的常见操作
     *  2. 映射
     *   *  2.1 不可变Map
         *  2.2 可变Map
         *  2.3 Map基本操作
     *  3. 迭代器(iterator)
     *   *  3.1 概述
         *  3.2 注意事项

[★ Scala ★——方法def 与 函数 细则，99乘法表案例实现][Scala _def _ _ _99]

[★ Scala ★——类和对象（伴生对象）大全细则][Scala]

[★ Scala ★——继承、方法重写、抽象类、匿名类大全细则][Scala 1]

[★ Scala ★——Trait特质大全细则][Scala _Trait]

[★ Scala ★ —— 数据结构（列表、元组、数组）][Scala _ _]

[★ Scala ★ —— 数据结构（集、映射、迭代器）][Scala _ _ 1]

## 集 ##

### 1.1 概述 ###

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

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

### 1.2 不可变集 ###

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

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

### 1.3 可变集 ###

#### 1.3.1概述 ####

可变集指的是元素, 集的长度都可变, 它的创建方式和不可变集的创建方式一致，只不过需要先导入可变集类。  
手动导入： `import scala.collection.mutable.Set`

### 1.4 不可变集的常见操作 ###

**格式：**

1.  获取集的大小（ size ）
2.  遍历集（ 和遍历数组一致 ）
3.  添加一个元素，生成一个新的Set（ + ）
4.  拼接两个集，生成一个新的Set（ ++ ）
5.  拼接集和列表，生成一个新的Set（ ++ ）
6.  \-(减号) 表示删除一个元素, 生成一个新的Set
7.  – 表示批量删除某个集中的元素, 从而生成一个新的Set

package Data_Structure
    
    object ClassDemo7 {
        
      def main(args: Array[String]): Unit = {
        
        val set1 = Set(1,1,12,35,56,16,4,8,8) // 创建一个集
        println(s"set1的元素为: ${set1};\nset1的长度为: ${set1.size}") // 获取集的大小
    
        val set2 = set1 - 12
        val set3 = set2 ++ Set("李四","孙明") // 拼接另一个集
        val set4 = set3 -- List(56,4,8) // 拼接一个列表
        for(i <- set4) print(" " +i) // 遍历集，打印每个元素
    
      }
    }

![在这里插入图片描述][20210214204942464.png]

## 2. 映射 ##

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

### 2.1 不可变Map ###

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

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

### 2.2 可变Map ###

**特点：** 可变Map指的是元素, 长度都可变. 定义语法与不可变Map一致, 只不过需要先手动导包: `import scala.collection.mutable.Map`

### 2.3 Map基本操作 ###

格式：

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

package Data_Structure
    import scala.collection.mutable.Map
    object ClassDemo8 {
        
      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}")
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]

## 3. 迭代器(iterator) ##

### 3.1 概述 ###

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

### 3.2 注意事项 ###

使用 iterator 方法可以从集合获取一个迭代器  
迭代器中有两个方法：

*  **hasNext方法:** 查询容器中是否有下一个元素
 *  **next方法:** 返回迭代器的下一个元素，如果没有，抛出NoSuchElementException

每一个迭代器都是有状态的  
即: 迭代完后保留在最后一个元素的位置. 再次使用则抛出NoSuchElementException

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

package Data_Structure
    
    //案例: 演示迭代器
    object ClassDemo9 {
        
      def main(args: Array[String]): Unit = {
        
        //定义一个列表
        val list1 = List(1, 2, 3, 4, 5)
        // 获取其对应的迭代器对象.
        val it = list1.iterator
        // 判断迭代器中是否有下一个元素.
        while(it.hasNext){
        
          // 如果有, 则获取下一个元素, 并打印.
          println(it.next)
        }
        println("-" * 15)
        // 迭代完后, 再次使用该迭代器获取元素, 则抛异常: NoSuchElementException
        println(it.next)
      }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]

[Scala _def _ _ _99]: https://blog.csdn.net/weixin_44775255/article/details/112661448
[Scala]: https://blog.csdn.net/weixin_44775255/article/details/112680051
[Scala 1]: https://blog.csdn.net/weixin_44775255/article/details/113093432
[Scala _Trait]: https://blog.csdn.net/weixin_44775255/article/details/113373647
[Scala _ _]: https://blog.csdn.net/weixin_44775255/article/details/113788952
[Scala _ _ 1]: https://blog.csdn.net/weixin_44775255/article/details/113810814
[20210214204942464.png]: /images/20221024/cf06f9ce2124417dbfb3c1a7bd0ec75d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70]: /images/20221024/68b36fdec863459b981d01ecd9e03e9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/0b5204eed5bb4361971ae89fdd3fd66d.png