零、本讲学习目标

1. 掌握数组的使用
2. 掌握列表的使用
3. 掌握映射的使用
4. 掌握集合的使用
5. 掌握元组的使用

Scala集合(collection)分为可变集合(mutable collection)和不可变集合(immutable collection)。可变集合可以对其中的元素进行修改、添加、移除；而不可变集合永远不会改变，但是仍然可以模拟添加、移除或更新操作。这些操作都会返回一个新的集合，原集合的内容不发生改变。

一、数组 (Array)

• Scala中的数组分为定长数组和变长数组，定长数组初始化后不可对数组长度进行修改，而变长数组则可以修改。

（一）定长数组

• Array的API文档：https://www.scala-lang.org/api/current/scala/Array.html
  

1、数组定义

（1）定义数组时初始化数据

• 自动推断数组类型
  

• 手动指定数据类型
  
  

（2）定义时指定数组长度，后赋值

• 先定义，后赋值
  

• 避免数组下标越界错误
  

2、数组遍历

• 定义数组arr（自动推断类型，静态初始化）
  
• 可以使用for循环对数组进行遍历，输出数组所有的元素

（1）传统for循环方式

• 通过数组下标来遍历数组元素
  

• 大家可以看到，反向遍历没有输出结果，怎么解决这个问题？

• 参考一下Java正向和反向遍历数组，看能否得到启发
  

• 通过arr.length - 1 to 0 by -1实现反向遍历
  

• 说明：num1 to num2 by 1 相当于 num1 to num2

（2）增强for循环方式

• 正向遍历数组元素
  
• 反向遍历数组元素
  

（3）利用foreach算子遍历数组

• 联想Java里列表的forEach()方法结合Lambda表达式
  
• 利用Scala的foreach算子来遍历数组
  

课堂练习：数组求和

• 采用遍历算子
  
• 采用增强for循环
  
• 课堂练习：采用传统for循环来求和
  

3、常用方法

• Scala对数组提供了很多常用的方法，使用起来非常方便
• 定义数组arr（通过数组类的构造方法来初始化数组，静态初始化）
  
• 对数组arr也可以采用先定义后赋值的方式（动态初始化）
  

（1）求数组中数值总和

• 调用sum方法
  

（2）求数组中的最大值

• 调用max方法
  

（3）求数组中的最小值

• 调用min方法
  

（4）对数组实现升序

• 调用sorted方法
  
• 不可变数组调用sorted方法之后会产生一个新的排序数组，而原来的数组保持不变

（5）对数组实现降序

• 先调用sorted方法升序，再调用reverse方法反序，就可以实现数组降序
  

课堂练习：数组查询

• 定义一个整型数组，输入一个整数，判断该整数是否在数组里，如果在数组里，给出其位置，否则提示用户该整数不在数组里。

• 在net.huawei.day03包里创建Exercise01对象
  

• 利用数组的contains方法判断查询目标是否在数组里，如果在数组里，就遍历输出

• 运行结果
  
  
  

• 直接遍历输出等于查询目标的数组元素，统计统计满足条件的个数，如果个数等于零，说明查询目标不在数组里

• 在net.huawei.day03包里创建Exercise01_对象
  

• 运行程序
  
  
  

（二）变长数组

• ArrayBuffer的API文档：https://www.scala-lang.org/api/2.11.x/index.html#scala.collection.mutable.ArrayBuffer
  

1、数组定义

• 变长数组使用类scala.collection.mutable.ArrayBuffer进行定义

• 定义一个变长Int类型数组arr
  

• 利用+=运算符添加数组元素（注意是追加元素）
  

• 遍历数组arr，跟遍历定长数组没有不同
  

• 利用-=运算符删除数组元素
  

• 数组中有多个值为4的元素，则从前向后删除第一个匹配的元素，本次删除，第一个4被删除了，但是第二4还依然存在。

2、数组合并

• Scala支持使用++=符号将两个变长数组进行合并
• 定义两个变长数组arr1和arr2，合并生成变长数组arr3
  
• 注意：arr1会是合并后的数据，即ArrayBuffer(1, 2, 3, 4, 5, 6, 7, 8)
• 数组arr2和arr1，合并生成变长数组arr4
  

3、插入元素

• 使用insert()方法可以在数组指定位置插入一个元素
• 在数组arr的下标为1的位置插入一个元素666
  
• 注意：一次插入多个元素是要报错的
  
• 如果插入的位置参数超出数组的长度，报错
  
• 如果插入的位置参数等于数组长度，那么就相当于在末尾追加新元素
  

课堂练习：产生随机整数构成的变长数组

• 产生一个变长数组，包含10个100以内的随机整数
  
• 三种方式来产生10个随机整数构成的变长数组
  

4、移除元素

• 使用remove()方法可以在数组的固定位置移除指定数量的元素
• 从数组arr的下标为1的位置开始移除2元素
  
• 如果移除起始位置+删除数量 > 数组长度，那么就会报错
  

二、列表 (List)

• Scala中的列表分为可变列表和不可变列表，默认使用的列表为不可变列表。不可变列表也可以增加元素，但实际上生成了一个新列表，原列表不变。列表元素类型可以相同，也可以不一致。

（一）不可变列表

• List的API文档：https://www.scala-lang.org/api/2.11.x/index.html#scala.collection.immutable.List
  

1、创建不可变列表

• 创建一个Int类型的列表- list1
  
• 创建一个混合类型的列表 - list2，元素类型被系统统一为Any
  

2、给列表添加元素

（1）在列表头添加元素

• 利用.+:在列表头添加新元素
• 在列表list1的头部追加一个元素0，生成一个新列表 list3，列表list1没有变的
  
• 利用::在列表头添加新元素
  

（2）在列表尾添加元素

• 利用.:+在列表尾添加新元素
• 在列表list1的尾部追加一个元素100，生成一个新列表 list4，列表list1没有变的
  

3、列表合并操作

• List也支持合并操作
• 创建两个列表list1和list2
  
• list1与list2合并生成列表list3，list1元素在前，list2元素在后
  
• list1与list2合并生成列表list4，list2元素在前，list1元素在后
  

4、二维列表

• 列表的列表称为二维列表
• 定义二维列表students
  

val students: List[List[Any]] = List(
    List(1, "李文丽", 19),
    List(2, "肖玉玲", 18),
    List(3, "郑刚林", 20))

• 遍历二维列表students
  

for (student <- students) {
    for (field <- student)
        print(field + "\t")
    println()
}

• 课堂练习：两种方式遍历二维列表
  
  

（二）可变列表

• ListBuffer的API文档：https://www.scala-lang.org/api/2.11.x/index.html#scala.collection.mutable.ListBuffer
  

1、创建可变列表

• 可变List需要使用scala.collection.mutable.ListBuffer类
• 创建列表时初始化数据
  
• 先创建空列表，然后添加数据
  

2、列表合并

• 将列表list1与列表list2合并，list1在前，list2在后
  
• 将列表list1与列表list2合并，list2在前，list1在后
  
• 注意，哪怕执行list1 :++ list2，依然是list1在前，list2在后
  

3、列表排序

• 列表升序和降序
  

4、列表总和、平均值、最值

• 计算总和、最值可以直接调用列表方法完成，平均值得自己计算
  

5、添加新元素

• 调用可变列表的insert(pos, value)，在pos位置插入新元素value
  
• 特殊情况，在列表头插入新元素，pos = 0
  
• 特殊情况，在列表尾追加新元素，pos = list.length
  

6、移除列表元素

• 调用可变列表的remove(pos, count)，从pos位置开始移除count个列表元素
• 任务：移除list列表中的(1, 2, 3)元素
  

课堂练习

1. 创建整型可变空列表，添加1、3、5、7四个元素，在5和7之间插入元素6，移除开头的1、3两个元素，统计列表元素总和、最大值和最小值，最后将列表降序输出。
2. 创建整型列表，包含12、5、8、12、9、7、45、16、78、10、3，分别输出奇数列表和偶数列表。
   

三、映射 (Map)

• Scala中的Map也分可变Map和不可变Map，默认为不可变Map。

（一）不可变映射

1、创建不可变映射

• 创建不可变映射mp，用键->值的形式
  
• 创建不可变映射mp，用(键, 值)的形式
  
• 注意：Map是抽象类，不能实例化
  

2、遍历不可变映射

• 调用mp.keys的foreach实现遍历
  
• 利用for循环来实现遍历
  

（二）可变映射

• 创建可变Map需要引入类scala.collection.mutable.Map，创建方式与上述不可变Map相同。

1、创建可变映射

• 创建可变映射mmp
  

2、修改可变映射

• 将键02的值改为man（键02存在，执行修改操作）
  
• 将键05的值改为belle（键05存在，执行添加操作）
  

3、查询可变映射

• 查询键02的值，如果没有查到，则返回-1
  
• 查询键08的值，如果没有查到，则返回-1
  

4、添加元素

• 查看可变映射当前值
  
• 用两种方式添加元素
  

5、删除元素

• 删除存在的键 - 07 对应的元素
  
• 删除不存在的键 - 11 对应的元素，不报错，映射也没有变化
  

四、元组 (Tuple)

• 元组是一个可以存放不同类型对象的集合，元组中的元素不可以修改。

（一）定义元组

1、直接赋值定义元组

• 定义一个元组student
  

2、创建指定长度的元组

• 定义指定长度的元组，其中Tuple3是一个元组类，代表元组长度为3
  

• 目前，Scala支持的元组最大长度为22，即可以使用Tuple1到Tuple22。元组的实际类型取决于元素数量和元素的类型。
  

（二）访问元组

• 使用方法_1、_2、_3访问元组的元素，与数组和字符串的位置不同，元组的元素下标从1开始。
• 访问元组的3个元素
  
• 访问元组的第6个元素（不存在的元素），报错
  

（三）迭代元组

• 直接用for循环遍历元素是不行的
  
• 使用元组的productIterator()方法产生全部元素构成的迭代器，然后遍历迭代器
  
• 使用for循环遍历元组生成迭代器
  

（四）元组转为字符串

• 使用Tuple.toString()方法可将元组全部元素组合成一个字符串
  
• 注意：元组与字符串进行连接运算，元组会自动转换成字符串

课堂练习：对一个字符串进行词频统计

• 读取磁盘文件，然后输出
  
  
  
  
• 采用Spark的RDD来进行词频统计，明显要简单得多
  

五、集合 (Set)

• Scala Set集合存储的对象不可重复。Set集合分为可变集合和不可变集合，默认情况下，Scala使用的是不可变集合，如果要使用可变集合，就需要引用scala.collection.mutable.Set类。
• 集合的三大特点：确定性、互异性、无序性
• 关于Set的API文档：https://www.scala-lang.org/api/2.11.x/index.html#scala.collection.mutable.Set
  

（一）定义集合

• 定义一个空的不可变集合set1（Nothing - 一无所有，Scala所有类的子类）
  

• 定义一个非空的不可变集合set2（Any - 包罗万象，Scala所有类的父类）
  

（二）增减元素

• 与列表一样，对于不可变集合进行元素的增加和删除实际上会产生一个新集合，原来的集合并没有改变
• 创建一个不可变集合set
  
• 添加一个集合不存在的元素 - 100
  
• 添加一个集合存在的元素1，集合里始终只有一个1（集合具有互异性）
  
• 当然，2和3两个元素也是加不进去的
  
• 减去一个存在的元素2
  
• 减去一个不存在的元素666
  

（三）集合方法

• 创建一个集合cities
  

1、获取首元素

• 调用head方法
  

2、获取去首子集合

• 调用tail方法，去掉了集合里的第一个元素Shenzhen
  

课堂练习：删除排前的三个城市

• 去掉了排前的三个城市：Shenzhen、Beijing和Luzhou
  

3、两个集合求并集

• 利用++求两个集合的并集
• 两个集合都有6和2，但是并集里只出现1次
  

4、两个集合求交集

• 利用.&或.intersect()方法求两个集合的交集
  

5、求集合的最值

• 利用max和min方法求集合最值
  

六、课后作业

任务：IP地址去重

• 在项目根目录创建ips.txt文件
• 创建RemoveRepeatedIPs对象完成去重工作
  

192.168.234.21
192.168.234.22
192.168.234.21
192.168.234.21
192.168.234.23
192.168.234.21
192.168.234.21
192.168.234.21
192.168.234.25
192.168.234.21
192.168.234.21
192.168.234.26
192.168.234.21
192.168.234.27
192.168.234.21
192.168.234.27
192.168.234.21
192.168.234.29
192.168.234.21
192.168.234.26
192.168.234.21
192.168.234.25
192.168.234.25
192.168.234.21
192.168.234.22
192.168.234.21

• 运行程序，查看结果
  

---

• 上传ips.txt到ied虚拟机的/home目录
  
• 启动Scala，导入scala.io.Source类，利用它提供的方法可以读取文件
  
• 读取文件/home/ips.txt文件，返回文件行lines迭代器
  
• 利用foreach遍历算子来遍历lines迭代器
  
• 创建一个空的字符串集合
  
• 利用for循环遍历文件行迭代器，将每一行添加到集合
  
• 利用遍历算子遍历集合
  
• 导入文件字符输出流
  
• 创建文件字符输出流对象，指定写入的文件
  
• 利用for循环遍历集合，将每个元素分行写入指定文件
  
• 关闭文件字符输出流
  
• 查看生成的distinct_ips.txt文件内容