一.Array的定义

在 Scala 里，Array 本质上是一种用来存放固定长度、同一类型元素的数据结构。

它的元素会连续地排布在内存中。也正因为这一点，读取和访问元素时通常都很高效、很快。

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

二.不可变数组

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

常规操作

• 创建数组
• 访问元素：注意不要越界（越界会）
• 获取数组的长度：arr.length：获取数组的长度。

package array

/**
 * Array 和 List 的区别
 *
 * array:有序，数组：元素在空间上连续，通过下标去访问元素会特别快！
 * List:有序，链表：元素在空间上不连续
 *
 * 两种类型
 * 1.可变
 * 2.不可变：一个数组创建之后，不能添加，不能删除！
 *
 * 常用方法：添加，删除，查找，循环，排序，.....
 */

object array01 {
  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)
    // 不可变数组不能直接修改，拼接生成新数组
    // val arr2 = arr2 :+ 4
    println(arr2)
  }
}

三.可变数组

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

基本操作

• 新建。要先导入 ArrayBuffer。 可变的数据结构都需要额外导入
• 访问修改。数组名(下标)=新值。

添加元素

• 添加一个元素；+= 元素
• 添加多个元素；+=(元素1, 元素2)

删除元素

• 删除一个元素： -= 元素
• 删除多个元素： -= (元素1, 元素2）
• 删除指定位置的元素： remove(下标)
• 删除指定位置的多个元素：remove(下标起点，下标终点)

package array

/**
 * Array 和 List 的区别
 *
 * array:有序，数组：元素在空间上连续，通过下标去访问元素会特别快！
 * List:有序，链表：元素在空间上不连续
 *
 * 两种类型
 * 1.可变
 * 2.不可变：一个数组创建之后，不能添加，不能删除！
 *
 * 常用方法：添加，删除，查找，循环，排序，.....
 */

object array03 {
  def main(args: Array[String]): Unit = {
    // 创建1到99的数组（左闭右开）
    val arr = Array.range(1, 100)
    arr.foreach(println) // 打印1-99

    // 创建1到99、步长为3的数组
    val arr1 = Array.range(1, 100, 3)
    arr1.foreach(println) // 打印1、4、7...97

    // 定义数组
    val arr2 = Array(1,2,3)
    // 访问数组元素
    println(arr2(0)) // 输出第一个元素：1
    println(arr2(2)) // 输出第三个元素：3
    // println(arr2(20)) // 注释：会触发数组越界异常
  }
}

package array

/**
 * Array 和 List 的区别
 *
 * array:有序，数组：元素在空间上连续，通过下标去访问元素会特别快！
 * List:有序，链表：元素在空间上不连续
 *
 * 两种类型
 * 1.可变
 * 2.不可变：一个数组创建之后，不能添加，不能删除！
 *
 * 常用方法：添加，删除，查找，循环，排序，.....
 */


object array03 {
  def main(args: Array[String]): Unit = {
    // 定义可变数组
    val arr1 = scala.collection.mutable.ArrayBuffer(1,2,3)

    // 追加元素（单个）
    arr1 += 4
    // 追加元素（多个）
    arr1 ++= Array(5,6,7)

    // 删除元素：删除下标为1的元素
  //  arr1.remove(0)
    // 删除元素：从下标0开始，删除3个元素
    arr1.remove(0, 3)

    // 修改元素：将下标为0的元素改为700
    arr1(2) = 700

    // 查找元素：判断是否包含指定值
    println(arr1.contains(6))  // 输出false（原元素已被删除）
    println(arr1.contains(8))// 输出true
    
    println(arr1.sum)//求和

    // 遍历数组
    arr1.foreach(ele => println(ele))
  }
}

四.数组常用方法

数组常用方法主要包括映射、过滤、搜索和切片。

• 映射（Map）。arr.map(f)：对数组中的每个元素应用函数f，并返回一个新的不可变数组。
• 过滤（Filter）。任务搜索
• 搜索和比较

arr.indexOf(elem)：返回元素elem在数组中的第一个索引。

arr.contains(elem)：检查数组是否包含元素elem。

• 切片（Slice）

arr.slice(from, until)：用于从数组里截取一段内容，返回的是一个新的子数组。起点是索引 from，终点到索引 until 为止，但不包含 until 本身。

package array


object array04 {
def main(args: Array[String]): Unit = {
  // 定义可变数组
  val arr1 = scala.collection.mutable.ArrayBuffer(1,2,0,-1,20,3)

  // 排序：降序排序（a > b）
  val arr2 = arr1.sortWith((a, b) => a > b)

  // 切片：获取下标0（包含）到3（不包含）的元素
  val arr3 = arr1.slice(0, 3)

  // 过滤：保留大于0的元素
  val arr4 = arr1.filter(x => x > 0)

  // 搜索元素下标：查找-2的位置（不存在则返回-1）
  val target = -2
  val result = arr1.indexOf(target)
  println(s"${target}的下标是 ${result}")

  // 遍历过滤后的数组
  arr4.foreach(ele => println(ele))
}
}

五.多维数组

最典型的多维数组就是二维数组，类似于表格。

有两种定义方式：

• 直接定义： Array.ofDim(x,y)
• 从一维数组转化得来： 数组. grouped()

练习题

package caseclass

import scala.collection.mutable.ListBuffer
import scala.collection.mutable.ArrayBuffer
import ja va.time.LocalDate

// 1. 使用case class定义DreamItem类
case class DreamItem(
                      content: String,    // 内容
                      isCompleted: Boolean, // 是否完成
                      deadline: LocalDate,  // 截止日期
                      priority: Int       // 优先级
                    )

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

    // 3. 添加3个梦想
    dreamArr += DreamItem("学scala", false, LocalDate.of(2025,12,31), 2)
    dreamArr += DreamItem("练字", false, LocalDate.of(2026,1,15), 3)
    dreamArr += DreamItem("减肥", false, LocalDate.of(2025,12,20), 1)

    // 4. 将第2个梦想设置为已完成
    dreamArr(1) = dreamArr(1).copy(isCompleted = true)

    // 5. 调高第3个梦想的优先级
    dreamArr(2) = dreamArr(2).copy(priority = dreamArr(2).priority + 2)

    // 6. 根据优先级从高到低排序
    val sortedDreams = dreamArr.sortWith((a,b) => a.priority > b.priority)

    // 7. 保存优先级排名前5的梦想
    val top5Dreams = sortedDreams.slice(0,5)

    // 8. 循环输出梦想列表
    top5Dreams.foreach(dream => {
      println(s"内容：${dream.content}，完成：${dream.isCompleted}，截止日：${dream.deadline}，优先级：${dream.priority}")
    })
  }