Scala 高阶（七）：集合内容汇总（上篇）

大家好，我是百思不得小赵。

创作时间：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 :+18val newArray4 =19+:28+: newArray3 :+87:+98
    println(newArray4.mkString("--"))}}

第二种创建方式使用 apply 方法创建数组对象
添加元素时：在前，对象在前，：在后，对象在后。
访问元素使用()运算符，通过apply/update方法实现，源码中的实现只是抛出错误作为存根方法（stab method），具体逻辑由编译器填充。

可变数组

如何定义？

val arr =new ArrayBuffer[Int]()

[Int]表示存放整型的数据
()初始化的数据，整型默认为0
ArrayBuffer 需要引入 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 +=1927+=: 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 :+20val list4 = list2.::(23)

Nil.::(元素)创建新的列表，29 :: 99 :: 80 :: 43 :: Nil相当于给列表头部一直添加元素，定义一个新列表。
合并连个列表：list1 :: list2将list1整个列表合并到list2。list1 ::: list2 或者list1 ++ list2 将list1的各个元素合并到list2。++底层也是调用:::

可变ListBuffer

如何定义？

importscala.collection.mutableval 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.创建Setval set1 = Set(12,78,90,56,78,12,34,23)
    println(set1)// 2。添加元素val set2 = set1 +80
    println(set2)// 3。合并setval 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.创建Setval 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中所有对Keyfor(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。创建Mapval 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语言有所帮助！！！
在这里插入图片描述

标签： scala java 开发语言

本文转载自: https://blog.csdn.net/Zp_insist/article/details/125574644
版权归原作者 百思不得小赵 所有，如有侵权，请联系我们删除。

Scala 高阶（七）：集合内容汇总（上篇）

文章目录

一、概述

二、数组（Array）

不可变数组

可变数组

三、列表（List）

不可变List

可变ListBuffer

四、Set集合

不可变Set

可变Set

五、Map集合

不可变Map

可变Map

六、元组

发表评论

“Scala 高阶（七）：集合内容汇总（上篇）”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航