Scala 之 Array, ArrayBuffer 详解

1. 第一种方法定义数组
   这里的数组等同于 Java 中的数组,中括号的类型就是数组的类型
   val arr1 = new Array[Int](10), 集合元素采用小括号访问
   arr1(1) = 7

object ArrayDemo01 {
  def main(args: Array[String]): Unit = {
    //说明
    //1. 创建了一个 Array 对象,
    //2. [Int] 表示泛型，即该数组中，只能存放 Int
    //3. [Any] 表示 该数组可以存放任意类型
    //4. 在没有赋值情况下，各个元素的值 0
    //5. arr01(3) = 10 表示修改 第 4 个元素的值
    val arr01 = new Array[Int](4) //底层 int[] arr01 = new int[4]
    println(arr01.length) // 4
    println("arr01(0)=" + arr01(0)) // 0
    for (i <- arr01) { //数据的遍历
      println(i)
    }
    arr01(3) = 10
    for (i <- arr01) {
      println(i)
    }
  }
}

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

object ArrayDemo02 {
  def main(args: Array[String]): Unit = {
    //说明
    //1. 使用的是 object Array 的 apply
    //2. 直接初始化数组，这时因为你给了 整数和 "", 这个数组的泛型就 Any
    //3. 遍历方式一样
    val arr02 = Array(1, 3, "xx")
    arr02(1) = "xx"
    for (i <- arr02) {
      println(i)
    }
    //可以使用我们传统的方式遍历，使用下标的方式遍历
    for (index <- arr02.indices) {
      printf("arr02[%d]=%s", index, arr02(index) + "\t")
    }
  }
}

3. 数组-变长数组(声明泛型)
   1. ArrayBuffer是变长数组，类似java的ArrayList
   2. val arr2 = ArrayBuffer[Int]() 也是使用的 apply 方法构建对象
   3. def append(elems: A*) { appendAll(elems) } 接收的是可变参数.
   4. 每 append 一次，arr 在底层会重新分配空间，进行扩容，arr2 的内存地址会发生变化，也就成为新的ArrayBuffer

import scala.collection.mutable.ArrayBuffer

object ArrayBufferDemo01 {
  def main(args: Array[String]): Unit = {
    //创建 ArrayBuffer
    val arr01 = ArrayBuffer[Any](3, 2, 5)
    //访问，查询
    //通过下标访问元素
    println("arr01(1)=" + arr01(1))
    arr01(1) = 2 //遍历
    for (i <- arr01) {
      println(i)
    }
    println(arr01.length) //3
    println("arr01.hash=" + arr01.hashCode())
    //修改 [修改值，动态增加]
    //使用 append 追加数据 ,append 支持可变参数
    //可以理解成 java 的数组的扩容
    arr01.append(90.0, 13)
    //(3,2,5,90.0,13)
    println("arr01.hash=" + arr01.hashCode())
    println("===================")
    arr01(1) = 89 //修改 (3,89,5,90.0,13)
    println("--------------------------")
    for (i <- arr01) {
      println(i)
    }
    //删除... 
    //删除,是根据下标来说
    arr01.remove(0)
    //(89,5,90.0,13)
    println("--------删除后的元素遍历---------------")
    for (i <- arr01) {
      println(i)
    }

    println("最新的长度=" + arr01.length) // 4
  }

}

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

object MultiplyArray {
  def main(args: Array[String]): Unit = {
    //创建
    val arr = Array.ofDim[Int](3, 4)
    //遍历
    for (item <- arr) { //取出二维数组的各个元素(一维数组)
      for (item2 <- item) { // 元素(一维数组) 遍历
        print(item2 + "\t")
      }
      println()
    }
    //指定取出 println(arr(1)(1)) // 0
    //修改值
    arr(1)(1) = 100
    //遍历
    println("=====================")
    for (item <- arr) { //取出二维数组的各个元素(一维数组)
      for (item2 <- item) { // 元素(一维数组) 遍历
        print(item2 + "\t")
      }
      println()
    }
    //使用传统的下标的方式来进行遍历
    println("===================")
    for (i <- arr.indices) { //先对
      for (j <- arr(i).indices) {
        printf("arr[%d][%d]=%d\t", i, j, arr(i)(j))
      }
      println()
    }
  }
}