不可变数组

第一种方式定义数组

定义：val arr1 = new ArrayInt
1）new是关键字
（2）[Int]是指定可以存放的数据类型，如果希望存放任意数据类型，则指定Any
（3）(10)，表示数组的大小，确定后就不可以变化

案例实操

  1. def main(args: Array[String]): Unit = {
  3.     //（1）数组定义
  4.     val arr01 = new Array[Int](4)
  5.     println(arr01.length) // 4
  7.     //（2）数组赋值
  8.     //（2.1）修改某个元素的值
  9.     arr01(3) = 10
  10.     //（2.2）采用方法的形式给数组赋值
  11.     arr01.update(0,1)
  13.     //（3）遍历数组
  14.     //（3.1）查看数组
  15.     println(arr01.mkString(","))
  17.     //（3.2）普通遍历
  18.     for (i <- arr01) {
  19.         println(i)
  20.     }
  22.     //（3.3）简化遍历
  23.     def printx(elem:Int): Unit = {
  24.         println(elem)
  25.     }
  26.      arr01.foreach(printx)
  27.     // arr01.foreach((x)=>{println(x)})
  28.     // arr01.foreach(println(_))
  29.     arr01.foreach(println)
  31.     //（4）增加元素（由于创建的是不可变数组，增加元素，其实是产生新的数组）
  32.     println(arr01)
  33.     val ints: Array[Int] = arr01 :+ 5
  34.     println(ints)
  35. }

第二种方式定义数组

val arr1 = Array(1, 2)
（1）在定义数组时，直接赋初始值
（2）使用apply方法创建数组对象

案例实操

def main(args: Array[String]): Unit = {

    var arr02 = Array(1, 3, "bobo")
    println(arr02.length)
    for (i <- arr02) {
        println(i)
    }
}

}

可变数组

定义变长数组

val arr01 = ArrayBufferAny
（1）[Any]存放任意数据类型
（2）(3, 2, 5)初始化好的三个元素
（3）ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer

案例实操
（1）ArrayBuffer是有序的集合
（2）增加元素使用的是append方法()，支持可变参数

def main(args: Array[String]): Unit = {

    //（1）创建并初始赋值可变数组
    val arr01 = ArrayBuffer[Any](1, 2, 3)

    //（2）遍历数组
    for (i <- arr01) {
        println(i)
    }
    println(arr01.length) // 3
    println("arr01.hash=" + arr01.hashCode())

    //（3）增加元素
    //（3.1）追加数据
    arr01.+=(4)
    //（3.2）向数组最后追加数据
    arr01.append(5,6)
    //（3.3）向指定的位置插入数据
    arr01.insert(0,7,8)
    println("arr01.hash=" + arr01.hashCode())

    //（4）修改元素
    arr01(1) = 9 //修改第2个元素的值
    println("--------------------------")

    for (i <- arr01) {
        println(i)
    }
    println(arr01.length) // 5
}

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

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

案例实操

def main(args: Array[String]): Unit = {

    //（1）创建一个空的可变数组
    val arr2 = ArrayBuffer[Int]()

    //（2）追加值
    arr2.append(1, 2, 3)
    println(arr2) // 1,2,3

    //（3）ArrayBuffer ==> Array
    //（3.1）arr2.toArray 返回的结果是一个新的定长数组集合
    //（3.2）arr2它没有变化
    val newArr = arr2.toArray
    println(newArr)

    //（4）Array ===> ArrayBuffer
    //（4.1）newArr.toBuffer 返回一个变长数组 newArr2
    //（4.2）newArr 没有任何变化，依然是定长数组
    val newArr2 = newArr.toBuffer
    newArr2.append(123)

    println(newArr2)
}

多维数组

多维数组定义
val arr = Array.ofDimDouble
说明：二维数组中有三个一维数组，每个一维数组中有四个元素

案例实操

def main(args: Array[String]): Unit = {

    //（1）创建了一个二维数组, 有三个元素，每个元素是，含有4个元素一维数组()
    val arr = Array.ofDim[Int](3, 4)
    arr(1)(2) = 88

    //（2）遍历二维数组
    for (i <- arr) { //i 就是一维数组

        for (j <- i) {
            print(j + " ")
        }

        println()
    }
}