Java集合框架
如果有Java基础，建议好好理解Java的集合框架和泛型，下文中Scala的集很简单，死噶啦！！！
集
概述：
Set(也叫: 集)代表没有重复元素的集合。
特点：
唯一、无序
解释：
- 1.唯一 的意思是 Set中的元素具有唯一性，没有重复元素。
- 2.无序 的意思是 Set集中的元素，添加顺序和取出顺序不一致。
Scala中的集分为俩种，一种是不可变集，另一种是可变集。
不可变集
不可变集指的是元素，集的长度都不可变。
语法：
- 格式一: 创建一个空的不可变集
- val/var 变量名 = Set[类型]()
- 格式二: 给定元素来创建一个不可变集
- val/var 变量名 = Set(元素1, 元素2, 元素3…)
代码实例：
- 定义一个空的整型不可变集.
- 定义一个不可变集，保存以下元素：1,1,3,2,4,8.
- 打印结果.
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,2,3,4,5
- 获取集的大小, 并打印结果.
- 遍历集，打印每个元素.
- 删除元素1，生成新的集, 并打印.
- 拼接另一个集Set(6, 7, 8), 生成新的集, 并打印.
- 拼接一个列表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,2,3, 4
- 添加元素5到可变集中
- 添加元素6, 7, 8到可变集中
- 从可变集中移除元素1 5. 从可变集中移除元素3, 5, 7
- 打印结果
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((键, 值), (键, 值), (键, 值), (键, 值)…)
代码实例：
- 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24, 李四 -> 40
- 打印结果.
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
代码实例：
- 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
- 修改张三的年龄为30
- 打印结果
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基本操作
- map(key) : 根据键获取其对应的值, 键不存在返回None.
- map.keys : 获取所有的键.
- map.values : 获取所有的值.
- 遍历map集合: 可以通过普通for实现.
- getOrElse: 根据键获取其对应的值, 如果键不存在, 则返回指定的默认值.
- +号 : 增加键值对, 并生成一个新的Map.
注意: 如果是可变Map, 则可以通过 +=或者++= 直接往该可变Map中添加键值对元素. - -号 : 根据键删除其对应的键值对元素, 并生成一个新的Map.
注意: 如果是可变Map, 则可以通过 -=或者–= 直接从该可变Map中删除键值对元素
代码实例：
- 定义一个映射，包含以下学生姓名和年龄数据: 张三 -> 23, 李四 -> 24
- 获取张三的年龄, 并打印.
- 获取所有的学生姓名, 并打印.
- 获取所有的学生年龄, 并打印.
- 打印所有的学生姓名和年龄.
- 获取 王五 的年龄，如果 王五 不存在，则返回-1, 并打印.
- 新增一个学生：王五, 25, 并打印结果.
- 将 李四 从可变映射中移除, 并打印
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中基本一样，同样是为了访问集合，而且很多方法非常相似。
注意事项：
- 1.使用 iterator 方法可以从集合获取一个迭代器。
- 迭代器中有俩个方法：
- hasNext方法: 查询容器中是否有下一个元素
- next方法: 返回迭代器的下一个元素，如果没有，抛出NoSuchElementException
- 迭代器中有俩个方法：
- 2.每一个迭代器都是有状态的。
- 即：迭代完后保留在最后一个元素的位置，再次使用则抛出NoSuchElementException
- 3.可以使用while或者for来逐个获取元素。
代码实例：
- 定义一个列表，包含以下元素：1,2,3,4,5
- 使用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)
扫一扫
543
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
