Scala中的Array

（一）Array的定义

Array 是一种在 Scala 中用于存储固定大小、相同类型元素的数据结构。它在内存中是连续存储的，这使得访问元素的速度非常快。

类型有两种：Array表示长度不可变的数组 和 ArrayBuffer表示长度可变的数组

Array和List的区别 Array：有序，数组：元素在空间上连续，通过下标去访问元素会特别快 List：有序，链表：元素在空间上不连续

（二）不可变数组

Array表示长度不可变的数组，一旦定义之后，不能再增加，删除元素。

（三） 可变数组

Array表示长度不可变的数组，一旦定义之后，不能再增加，删除元素。

array的可变与不可变

def main(args: Array[String]): Unit = {
  //可变数组
  val arr1 = scala.collection.mutable.ArrayBuffer(1,2,3);
  //可以直接添加元素
  arr1 += 4
  println(arr1)

  //不可变数组
 val arr2 = Array(1,2,3)
  //不可变，不能直接添加元素
  //arr2 += 4///报错
  println(arr2)
}

（四） array的创建及访问

def main(args: Array[String]): Unit = {
//快速创建
   Array(1,2,3)
   val arr = Array.range(1,100)
   arr.foreach(println)//1-99
   val arr1 = Array.range(1,100,3)//3,步长
   arr1.foreach(println)//1-99
  
  val arr1 = Array(1,2,3)
  //访问数组元素
  println(arr1(0))//第一个元素
  println(arr1(2))//第三个元素
  println(arr1(10))//报错：数组越界
}

（四） 针对可变数组的常用方法

1. 添加元素

(1) 添加一个元素：+= 元素

(2) 添加多个元素：+=(元素1, 元素2)

2. 删除元素

(1) 删除一个元素： -= 元素

(2) 删除多个元素： -= (元素1, 元素2）

(3) 删除指定位置的元素： remove(下标)

(4) 删除指定位置的多个元素：remove(下标起点，下标终点)

3. 修改元素

(1)修改指定位置元素：arr（a）= n

a：指定位置

n:改为指定数据

4. 排序元素

(1)sortWith((a,b)=>a>b)

按从大到小排序

5. 切片元素

（1）只取整个数组中的某个部分slice

（2）arr.slice(from, until)：返回数组的一个子数组，从索引from开始直到索引until（不包括until）。

6. 过滤元素

filter

7. 搜索位置

 def main(args: Array[String]): Unit = {
    //可变数组
    val arr1 = scala.collection.mutable.ArrayBuffer(1, 2, 3)
    //1添加
    arr1 += 4
    arr1 += (5, 6, 7)
    //2.删除
    arr1 -= 4 //----------删除某个下标上的元素
    //arr1.remove(0)
    arr1.remove(0, 3) //从指定位置开始删除，删除几个？
    //3.修改
    arr1(2) = 700
    //判断是否存在？
    println(arr1.contains(6)) //true
    println(arr1.contains(8)) //false
    println(arr1.sum) //求和
    arr1.foreach(ele => println(ele))
    
    
 val arr1 = scala.collection.mutable.ArrayBuffer(1, 2, 3,0,-1,20,3)
    //4排序
    val arr2 = arr1.sortWith((a,b)=>a>b)
    //5.切片:只取整个数组中的某个部分slice
    val arr3 = arr1.slice(0,3)
    //6.过滤
    val arr4 = arr1.filter(x => x>0)
    //7.搜索位置
    val target = -2
    val result = arr1.indexOf(target)//如果没有找到这个元素，就返回-1
    println(s"${target}的下标是${result}")
    arr4.foreach(ele => println(ele))
}

// 1. 定义DreamItem样例类
case class DreamItem(content: String, isDone: Boolean, deadline: String, prior: Int)

  def main(args: Array[String]): Unit = {
    // 2. 定义可变Array保存DreamItem
    import scala.collection.mutable.ArrayBuffer
    val dreamList = ArrayBuffer[DreamItem]()

    // 3. 添加3个梦想
    val dream1= DreamItem("学习Scala", false, "2025-12-31", 3)
    val dream2= DreamItem("读3本技术书", false, "2026-01-15", 2)
    val dream3= DreamItem("完成项目重构", false, "2026-02-28", 4)

    // 4. 将第2个梦想设为已完成（注意：Scala中索引从0开始）
    dreamList(1) =dreamList(1).copy(isDone = true)

    // 5. 调高第3个梦想的优先级（原优先级+1）
    dreamList(1) =dreamList(1).copy(prior = 0)

    // 6. 根据优先级从高到低排序
    val oderList = dreamList.sortBy(_.prior)

    // 7. 保存优先级前5的梦想（当前只有3个，全部保存）
    val top5Dreams = oderList.take(5)

    // 8. 循环输出梦想列表
  dreamList.foreach(ele =>{
      println("---------------------------------")
      println(s"内容：${ele.content} ")
      println(s"状态：${if (ele.isDone) "已完成" else "未完成"}")
      println(s"截止日期:${ele.deadline}")
      println(s"优先级：${ele.prior}")
      println("---------------------------------")
      println()
    })
  }