数组

1. Scala数组本质

Scala中Array的本质就是Java中的[]。比如：

def main(args: Array[String]): Unit = {
    val array = new Array[String](3)
    println(array)
}

执行结果和Java的数组打印都一样，除了地址不同：

2. 不可变数组

1. 第一种方式定义数组
   定义：val arr1 = new Array[Int](10)
   (1)new 是关键字
   (2)[Int]是指定可以存放的数据类型，也就是泛型符号，如果希望存放任意数据类型，则指定Any
   (3)(10)表示数组的大小，确定后就不可以变化

def main(args: Array[String]): Unit = {
    val array = new Array[String](3)
    println(array)
}

2. 第二种方式定义数组
   定义: val arr1 = Array(1, 2)
   (1)在定义数组时，直接赋初始值
   (2)使用apply()方法创建数组对象

def main(args: Array[String]): Unit = {
    // 使用apply方法传入内容，重载的方法很多支持不同类型的参数
    val array1: Array[Int] = Array.apply(3, 5)
    val array2: Array[Int] = Array.apply(110, 120)
    // apply()方法能够被编译器自动识别，可以省略不写
    val array3 = Array[Int](1, 2)
}

3. 操作数组

def main(args: Array[String]): Unit = {
    // 1. 创建数组
    val array1 = Array[Int](1, 2)
    // 2. 访问数组
    // 2.1 将数组转成字符串，用逗号隔开
    println(array1.mkString(","))
    // 2.2 for循环操作数组
    for (item <- array1) {
        println(item)
    }
    println("=========================")
    // 2.3 使用foreach打印数组元素
    array1.foreach(println(_))
    // 3. 修改数组
    val array2 = new Array[String](3)
    // Array只能通过索引的方式修改数据
    // Array访问时的索引操作采用小括号，而不是中括号
    array2(0) = "hello"
    array2(1) = "world"
    // 4. 增加元素，注意Array是不可变数组，这里的修改底层会创建新数组
    println("array1.hash=" + array1.hashCode())
    // 4.1 普通添加元素
    val array3 = array1.:+(5)
    val array4 = array1.+:(5)
    // 一般情况下，调用集合对象的特殊符号的方法时，都会采用运算符的方式来使用
    // 如果运算符采用冒号结尾，那么运算规则为从右向左计算
    val array5 = 5 +: array1
    val array6 = array1 :+ 6
    println(array5.mkString(", "))
    println(array6.mkString(", "))
    // 整体数组被添加
    // 方法一
    val array7 = array5 ++: array6
    println(array7.mkString(", "))
    // 方法二合并数组
    val array8: Array[Int] = Array(1, 2, 3)
    val array9: Array[Int] = Array(5, 6, 8)
    val array10: Array[Int] = Array.concat(array8, array9)
    println(array10.mkString(", "))
    println("*****************************")
    // 创建指定范围数组
    val array11: Array[Int] = Array.range(1, 5)
    array11.foreach(println)
    println("==============================")
    // 创建并填充指定数量的数组
    val array12: Array[Int] = Array.fill[Int](5)(-1)
    println(array12.mkString(" "))
}

运行结果：

3. 可变数组

1. 定义变长数组 定义： val arr01 = ArrayBuffer[Any](3, 2, 5)
   (1)[Any]存放任意数据类型
   (2)(3, 2, 5)初始化好的三个元素
   (3)ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer
2. 操作可变数组

def main(args: Array[String]): Unit = {
    // 集合 可变数组
    val arrayBuffer = new ArrayBuffer[Int]()
    val array: Array[Int] = Array(3, 5, 8)
    // 添加元素
    // append返回空对象
    val unitObj: Unit = arrayBuffer.append(1, 2, 3, 4)
    arrayBuffer.appendAll(array)
    println(arrayBuffer)
    // 修改
    array.update(1, 10)
    // updated会创建新的数组
    val arrayBuffer1: ArrayBuffer[Int] = arrayBuffer.updated(5, 9)
    println(arrayBuffer)
    // 删除
    arrayBuffer.remove(0)
    arrayBuffer.remove(3, 2)
    println(arrayBuffer)
    println("*****************************")
    // 查询
    println(arrayBuffer.mkString(", "))
    println(arrayBuffer.apply(2))
    println(arrayBuffer(2))
}

运行结果：

4. 多维数组

1. 多维数组定义： val arr = Array.ofDim[Double](3,4)
   说明：二维数组arr中有三个一维数组，每个一维数组中有四个元素
2. 遍历多维数组

def main(args: Array[String]): Unit = {
    // 创建多维数组
    val myMatrix: Array[Array[Int]] = Array.ofDim(3, 3)
    myMatrix.foreach(list => println(list.mkString(", ")))
}

运行结果：

5. 不可变与可变数组的转换

1. 不可变数组转可变数组
   arr1.toBuffer 返回结果才是一个可变数组，arr1 本身没有变化
2. 可变数组转不可变数组
   arr2.toArray 返回结果才是一个不可变数组，arr2 本身没有变化

def main(args: Array[String]): Unit = {
    val arrayBuffer: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3)
    val array: Array[Int] = Array(4, 5, 6)
    // 可变数组转不可变数组
    val array1: Array[Int] = arrayBuffer.toArray
    // 不可变数组转可变数组
    val buffer: mutable.Buffer[Int] = array.toBuffer
    println(array1.mkString(","))
    println(buffer.mkString(","))
}

6. 可变和不可变数组的选择

主要看原始数据是否需要改变：

1. 原始数据如果在很多地方使用(重复使用):不能变的
2. 原始数据如果使用后不再保留，那么使用可变