最新Scala 高阶（七）：集合内容汇总（上篇，大数据开发开发岗还不会这些问题

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

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://img-blog.csdnimg.cn/bb3d17175fb14eb6b068cd96727a4740.webp#pic_center)



![img](https://img-blog.csdnimg.cn/img_convert/adc67cf5ab52d9ea8302a377256b8bf8.png)
![img](https://img-blog.csdnimg.cn/img_convert/ff7ee7cacef4a02730906324f7103dd7.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

里插入图片描述](https://img-blog.csdnimg.cn/bb3d17175fb14eb6b068cd96727a4740.webp#pic_center)



[外链图片转存中...(img-Kvlq4WYA-1715813127983)]
[外链图片转存中...(img-lxOZjH2i-1715813127983)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**