大家好,企业管理系统定制开发我是百思不得小赵。
创作时间:2022 年 7 月 5 日
博客主页: 🔍
—— 企业管理系统定制开发新时代的农民工 🙊
—— 企业管理系统定制开发换一种思维逻辑去看待这个世界 👀
企业管理系统定制开发今天是加入CSDN的第1221天。企业管理系统定制开发觉得有帮助麻烦👏点赞、🍀评论、❤️收藏
文章目录
企业管理系统定制开发中的集合与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)
- 1
- 集合类型大多都支持泛型,语法是
[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("--")) }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 第二种创建方式使用
apply
方法创建数组对象 - 添加元素时
:
在前,对象在前,:
在后,对象在后。 - 访问元素使用()运算符,通过a
pply/update
方法实现,源码中的实现只是抛出错误作为存根方法(stab method),具体逻辑由编译器填充。
可变数组
如何定义?
val arr = new ArrayBuffer[Int]()
- 1
[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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
可变与不可变集合转换
- 不可变数组转可变数组
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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
多维数组
定义:
val array = Array.ofDim[Int](2, 3)
- 1
举个栗子:
// 创建二维数组 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))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
三、列表(List)
不可变List
如何定义?
val list: List[Int] = List(1,2,3,4,3)
- 1
List
默认为不可变集合,数据有序且可重复sealed
修饰的一个抽象的密封类。提供了一个约束,打包密封在当前文件内,当前类的子类不能定义在文件之外。- 本身是一个抽象类,不能使用
new
对象的方式,使用半生对象的apply
方法进行创建 - 遍历集合
list.foreach(println)
- 1
- 访问元素
println(list(1))
- 1
- 添加元素
+: :+
首尾添加元素,Nil
空列表,::
添加元素到表头
val list2 = list.+:(10) val list3 = list :+ 20 val list4 = list2.::(23)
- 1
- 2
- 3
- 4
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)
- 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)
- 1
- 默认为不可变的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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
可变Set
如何创建?
val set1 = mutable.Set(12,78,90,56,78,12,34,23)
- 1
- 添加元素:
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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
五、Map集合
不可变Map
如何创建?
val map1: Map[String, Int] = Map("a" -> 13, "b" -> 21, "hello" -> 80)
- 1
- 默认为不可变的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"))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
可变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
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
六、元组
元组也是可以理解为一个容器,可以存储相同或者不同类型的数据,换句话说就是将多个无关的数据封装为一个整体。
- 声明元组的方式:
(元素 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) }}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
本次Scala集合内容汇总的上篇到这里就结束了,内容篇幅较长,干货满满,希望对大家学习Scala语言有所帮助!!!