大家好，我是百思不得小赵。
创作时间：2022 年 7 月 5 日
博客主页： 🔍点此进入博客主页
—— 新时代的农民工 🙊
—— 换一种思维逻辑去看待这个世界 👀
今天是加入CSDN的第1221天。觉得有帮助麻烦👏点赞、🍀评论、❤️收藏
Scala中的集合与Java中的集合相类似，但是又有很多的改变，接下来我们开启Scala集合篇的学习历程吧！
一、概述
-
在
Java中的集合分为三大类：List集合、Set集合、Map集合。其中List集合、Set集合继承自Collection。它们都是接口。 -
Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。 -
对于几乎所有的集合类，Scala 都同时提供了可变和不可变的版本，分别位于以下两个包：不可变集合：
scala.collection.immutable、可变集合： scala.collection.mutable -
不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而
不会对原对象进行修改。类似于 java 中的 String 对象。 -
可变集合，就是这个集合可以直接对原对象进行修改，而不会返回新的对象。类似
于 java 中 StringBuilder 对象 -
Scala中的集合都是引用类型，并不关心指向的对象中的内容，只关心当前指向的对象。
-
建议：在操作集合的时候，不可变用符号，可变用方法。
不可变集合
- Scala中的Set 和 Map集合包含的类与Java相类似，不同的是Seq下面分为
IndexedSeq和LinearSeq两个特质。 - scala中的
String就是java.lang.String，和集合无直接关系，所以是虚箭头，是通过Perdef中的低优先级隐式转换来做到的。经过隐式转换为一个包装类型后就可以当做集合了。 IndexedSeq是通过索引来查找和定位，因此速度快，比如 String 就是一个索引集合，通过索引即可定位LinearSeq是线型的，即有头尾的概念，这种数据结构一般是通过遍历来查找.
可变集合
不可变和可变：
- 不可变指的是对象大小不可变，但是可以修改元素的值，需要注意这一点。而如果用了val不变量存储，那么指向对象的地址也不可变。
- 不可变集合在原集合上不能进行插入删除数据，只能返回新的集合。
二、数组（Array）
不可变数组
如何定义？
val array = new Array[Int](10)
- 集合类型大多都支持泛型，语法是
[Type]，不同于java的<Type>。 [Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any(10)，表示数组的大小，确定后就不可以变化
代码如下：
object Test01_ImmutableArray {
def main(args: Array[String]): Unit = {
// 创建数组
val array = new Array[Int](10)
// 另一种方式
val array2 = Array(10, 21, 65, 33, 78)
// 访问数组中的元素
println(array(0))
println(array(1))
println(array(2))
println(array(3))
// 修改值
array(0) = 12
array(2) = 23
println(array(0))
println(array(1))
println(array(2))
println("===============================")
// 数组遍历
// 1.普通for循环
for (i <- 0 until array.length) {
println(array(i))
}
for (i <- array.indices) println(array(i))
// 2.增强for循环
for (elem <- array2) println(elem)
// 3.迭代器
val iterator = array2.iterator
while (iterator.hasNext) println(iterator.next())
// 4.调用foreach方法
array2.foreach((elem: Int) => println(elem))
array.foreach(println)
// 5.转换为String
println(array2.mkString("--"))
println("=============================")
// 添加元素
// 加到数组后面
val newArray = array2.:+(90)
println(array2.mkString("--"))
println(newArray.mkString("--"))
// 加到数组前面
val newArray2 = newArray.+:(30)
println(newArray2.mkString("--"))
val newArray3 = newArray2 :+ 18
val newArray4 = 19+: 28 +: newArray3 :+ 87 :+ 98
println(newArray4.mkString("--"))
}
}
- 第二种创建方式使用
apply方法创建数组对象 - 添加元素时
：在前，对象在前，：在后，对象在后。 - 访问元素使用()运算符，通过a
pply/update方法实现，源码中的实现只是抛出错误作为存根方法（stab method），具体逻辑由编译器填充。
可变数组
如何定义？
val arr = new ArrayBuffer[Int]()
[Int]表示存放整型的数据()初始化的数据，整型默认为0ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer
代码实操：
//1。 创建可变数组
val arr = new ArrayBuffer[Int]()
// 另一种方式
val arr2 = ArrayBuffer(10, 21, 17, 9, 28)
println(arr.mkString("-"))
println(arr2)
// 2.访问元素
println(arr2(0))
// 修改元素
arr2(0) = 12
println(arr2(0))
// 3。向数组添加元素
// :+ 主要针对不可变数组来添加元素使用的，添加完元素后必须要将其赋给一个新的数组
val newArray1 = arr :+ 15
println(arr)
println(newArray1)
println(arr == newArray1) // false
// 可变数组添加元素调用 += 方法，添加完后无需赋给新的数组对象
// += 向后追加 +=: 向前追加
arr += 19
27 +=: arr
// 推荐使用append() 方法
// 向后追加
arr.append(36)
// 向前添加
arr.prepend(11, 90, 56)
// 在指定位置添加 arr.insert(索引位置,可变参数)
arr.insert(1, 23, 56)
//直接添加数组
arr.insertAll(2, arr2)
// arr.appendAll()
// arr.prefixLength()
// 4.删除元素
// 删除某个位置的元素
arr.remove(3)
// 从索引位置开始，删除xx个数
// arr.remove(0,10)
arr -= 36
可变与不可变集合转换
- 不可变数组转可变数组
arr1.toBuffer返回结果才是一个可变数组，arr1本身没有变化 - 可变数组转不可变数组
arr2.toArray返回结果才是一个不可变数组，arr2本身没有变化
举个栗子:
// 可变数组转为不可变数组
val array = ArrayBuffer(10, 21, 90)
val newArray = array.toArray
println(newArray.mkString("-"))
println(array)
// 不可变数组转为可变数组
val buffer = newArray.toBuffer
println(buffer)
println(newArray)
多维数组
定义：
val array = Array.ofDim[Int](2, 3)
举个栗子：
// 创建二维数组
val array = Array.ofDim[Int](2, 3)
// 访问元素
array(0)(2) = 19
array(1)(0) = 26
// 遍历
for (i <- 0 until array.length; j <- 0 until array(i).length) {
println(array(i)(j))
}
for (i <- array.indices; j <- array(i).indices) {
print(array(i)(j) + "\t")
if (j == array(i).length - 1) println()
}
array.foreach(line => line.foreach(println))
array.foreach(_.foreach(println))
三、列表（List）
不可变List
如何定义？
val list: List[Int] = List(1,2,3,4,3)
List默认为不可变集合,数据有序且可重复sealed修饰的一个抽象的密封类。提供了一个约束，打包密封在当前文件内，当前类的子类不能定义在文件之外。- 本身是一个抽象类，不能使用
new对象的方式，使用半生对象的apply方法进行创建 - 遍历集合
list.foreach(println)
- 访问元素
println(list(1))
- 添加元素
+: :+首尾添加元素，Nil空列表，::添加元素到表头
val list2 = list.+:(10)
val list3 = list :+ 20
val list4 = list2.::(23)
Nil.::(元素)创建新的列表，29 :: 99 :: 80 :: 43 :: Nil相当于给列表头部一直添加元素，定义一个新列表。- 合并连个列表：
list1 :: list2将list1整个列表合并到list2。
list1 ::: list2或者list1 ++ list2将list1的各个元素合并到list2。++底层也是调用:::
可变ListBuffer
如何定义？
import scala.collection.mutable
val listBuffer = new ListBuffer[Int]()
val buffer = mutable.ListBuffer(1,2,3,4)
- 可以使用
new对象的方式，也可使用伴生对象的apply方法创建 - 添加元素
append prepend insert添加元素到头或尾：+=: += - 合并集合：
list1 ++ list2或者list1 ++= list2前者得到新的列表，后者将元素合并到list1 - 修改元素：
list(index) = value底层调用update方法 - 删除元素：
remove或者-=
四、Set集合
默认情况下，Scala 使用的是不可变集合，如果你想使用可变集合，需要引用scala.collection.mutable.Set 包
不可变Set
如何创建？
val set1 = Set(12,78,90,56,78,12,34,23)
- 默认为不可变的Set，数据不可重复且无序。
- 初始化集合时数据会被去重，可以用做去重操作。
- 添加元素：
set + 元素 - 合并集合：
set1 ++ set2得到新的Set集合 - 删除元素：
set - 元素
代码实操：
// 1.创建Set
val set1 = Set(12,78,90,56,78,12,34,23)
println(set1)
// 2。添加元素
val set2 = set1 + 80
println(set2)
// 3。合并set
val set3 = Set(14,25,46,57,68,91)
val set4 = set2 ++ set3
println(set2)
println(set3)
println(set4)
// 4.删除元素
val set5 = set3 - 14
println(set3)
println(set5)
可变Set
如何创建？
val set1 = mutable.Set(12,78,90,56,78,12,34,23)
- 添加元素：
set += 元素调用add() - 删除元素：
set -= 元素调用remove() - 合并两个集合：
set1 ++= set2
代码实操：
// 1.创建Set
val set1 = mutable.Set(12,78,90,56,78,12,34,23)
println(set1)
/// 2.添加元素
val set2 = set1 + 32
set1 += 88
set1.add(30)
// 3.删除元素
set1 -= 12
set1.remove(23)
// 4.合并两个集合
val set3 = mutable.Set(75,90,56,39,54,51)
val set4 = set1 ++ set3
println(set4)
set1 ++= set3
println(set1)
五、Map集合
不可变Map
如何创建？
val map1: Map[String, Int] = Map("a" -> 13, "b" -> 21, "hello" -> 80)
- 默认为不可变的Map。
- 元素
key -> value键值对儿，为二元组类型。
代码实操：
// 1.创建Map key -> value 键值对儿
val map1: Map[String, Int] = Map("a" -> 13, "b" -> 21, "hello" -> 80)
println(map1)
println(map1.getClass)
// 2.遍历元素
for (elem <- map1) {
println(elem+"")
}
map1.foreach(println)
// 元组类型 (String, Int)
map1.foreach((kv: (String, Int)) => println(kv))
// 3.取Map中所有对Key
for (key <- map1.keys) {
println(s"${
key} ----> ${
map1.get(key)}")
}
// 4.访问某一个Key的value
// 不安全的，报空指针异常
println(map1.get("a").get)
println(map1.get("v"))
// 推荐使用
println(map1.getOrElse("f", 0))
println(map1("a"))
可变Map
类似于不可变的Map，直接上代码实操。
// 1。创建Map
val map1: mutable.Map[String, Int] = mutable.Map("a" -> 13, "b" -> 21, "hello" -> 80)
println(map1)
println(map1.getClass)
// 2.添加元素
map1.put("c",10)
map1.put("d",21)
println(map1)
map1 += (("e",90))
println(map1)
// 3.删除元素
println(map1.remove("e"))
println(map1.getOrElse("e", 0))
map1 -= "d"
println(map1)
// 4.修改元素
map1.update("a",21)
println(map1)
// 5.合并集合
val map2: Map[String, Int] = Map("o" -> 9, "y" -> 28, "hello" -> 80)
// 可变加不可变
map1 ++= map2
println(map1)
println(map2)
// 不可变加可变
val map3 = map2 ++ map1
println(map3)
六、元组
元组也是可以理解为一个容器，可以存储相同或者不同类型的数据，换句话说就是将多个无关的数据封装为一个整体。
- 声明元组的方式：
(元素 1，元素 2，元素 3,......) - 元组中最大能有22个元素，
Tuple1定义到了Tuple22。 - 访问元组：
_顺序号 - 通过索引访问元素
tuple.productElement(index) - 遍历元组：
for (elem <- tuple.productIterator)
举个栗子：
object Test_Tuple {
def main(args: Array[String]): Unit = {
// 1。创建元祖
val tuple = ("hello", 0, false,'a')
println(tuple)
// 2.访问元祖数据
println(tuple._1)
println(tuple._2)
println(tuple._3)
println(tuple._4)
println(tuple.productElement(0))
// 3.遍历元祖
for (elem <- tuple.productIterator){
println(elem)
}
// 4.嵌套元组
val mulTuple = (112,32,"aa",("scala",90))
println(mulTuple._4._2)
}
}
本次Scala集合内容汇总的上篇到这里就结束了，内容篇幅较长，干货满满，希望对大家学习Scala语言有所帮助！！！
转载：https://blog.csdn.net/Zp_insist/article/details/125574644
查看评论