Scala中的数据结构

数组（Array)

数组是一个可变的数据结构，长度固定，元素的类型必须一致。

Array是一个长度固定的数组，ArrayBuffer为一个长度可变的数组，可以动态添加和删除元素

var arr:Array[Int] = Array(1,2,3,4,5) // 一维数组
var arrM:Array[Array[Int]] =Array(Array(1,2,3,4),Array(5,6,7)) // 多维数组
arrM=Array.ofDim(4,4) //用方法声明多维数组
for(i <- arrM){ // 遍历
  for(j <- i){
    println(j)
  }
}
println(arr(0)) // 取值
println(arrM(1)(2)) //多维取值
val anyArr:Array[AnyVal] =Array(1,2.0,true) // AnyVal为这些类型公有的父类型，因此为同类型

该数据结构还有很多的方法例如max，min等，可以通过查询文档调用

 元组（Tuple）

元组（Tuple）是一种不可变的、有序的集合，允许不同类型的元素存储在其中。元组的大小是固定的，一旦创建，其元素个数不能改变。scala中为Tuple1到Tuple22，分被为1到22长度的元组

val t1:Tuple2[Int,String]=(0,"add") // 显示写法
val t2:(Int, String)=(1,"add") // 隐式写法
val t3=(1,true,"add") // 直接赋值
t3._3 //元组取值

列表（List）

List 是一种不可变的、有序的集合，用于存储相同类型的元素。它是基于链表实现的，每个元素都包含一个值和指向下一个元素的引用。由于是不可变的，对 List 进行操作会产生新的 List，而原始 List 不会受到影响。

ListBuffer 为动态可变列表

var l=List[Int](1,2,3,4,5,6)
l=1::2::3::4::Nil // 相当于用一个空列表加上前面的元素构成新列表

集合(Set)

Set 是一种集合类型，用于存储独特（不重复）元素。Set 提供了高效的成员检查操作，并且是不可变的，即一旦创建，其内容无法更改。

HashSet 为动态可变集合

映射（Map）

Map 是一种集合类型，用于存储键值对。每个键对应一个值，键是唯一的，且与值之间存在映射关系。Map 是不可变的，一旦创建，其内容不能被修改。

HashMap 为动态可变映射

val map1=Map[String,Int]("scala"->20,("java",60)) // 可以使用k->v,也可以用元组(k,v)
println(map1("scala")) // 取值
println(map1.get("scala")) // 取值
println(map1.getOrElse("python",0)) // 防止k不存在，如果不存在默认返回0
map1.keySet // 获取所有的key
map1.values // 获取所有的value
for(kv <- map1){ // 遍历map
   println(kv._1) // key
   println(kv._2) // value
}

数据结构的应用

可用于多变量声明

val List(a,b,c)=List(1,2,"c")
val Array(e,d,f)=Array(1,2,3)
println(a)

这里声明了a,b,c,e,d,f 六个变量，前三个变量类型为Any，后面三个为Int

类型转换

var a:Int=10
var b=a.toDouble
var c=a.asInstanceOf[Double]
println(b.getClass)
println(c.getClass)

懒加载（Lazy）

懒加载是一种延迟初始化的机制，它允许在第一次访问时才实际计算或初始化某个值。这可以节省资源，并且只有在需要的时候才进行计算。

def main(args: Array[String]): Unit = {
  val a=add(10,20)
  val b=add(10,20)
  println(a)
  println(b)
  println("===============")
  lazy val c = add(10, 20)
  lazy val d = add(10, 20)
  println(c)
  println(d)
}
def add(x:Int,y:Int):Int={
  println("加载记录一次")
  x+y
}

由测试结果可知，没有懒加载情况加，当赋值完该函数就会加载一次，而懒加载修饰后后，该函数的加载随着调用才会加载