不可变数组Array

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

（1）数组定义

val arr01 = new Array[Int](4)
println(arr01.length)

（2）数组赋值

//修改某个元素的值
arr01(3) = 10
//采用方法的形式给数组赋值
arr01.update(0, 1)

（3）遍历数组

//查看数组
println(arr01.mkString(","))
//普通遍历
for (i <- arr01) {
    println(i)
}
//简化遍历
def printx(elem: Int): Unit = {
    println(elem)
}
arr01.foreach(printx)
//arr01.foreach((x)=>{println(x)})
//arr01.foreach(println(_))
arr01.foreach(println)
for (i <- arr01.indices) println(arr01(i))

（4）增加元素
注意：由于创建的是不可变数组，增加元素，其实是产生新的数组

object hellowold {
  def main(args: Array[String]): Unit = {
    val arr = new Array[Int](5)
    arr.update(1, 20)
    println(arr.mkString(","))     //0,20,0,0,0
    val ints = arr :+ 30
    println(ints.mkString(","))        //0,20,0,0,0,30
    val int = 30 +: arr
    println(int.mkString(","))        // 30,0,20,0,0,0
  }
}

输出结果：
0,20,0,0,0
0,20,0,0,0,30
30,0,20,0,0,0

补充：：+ 数组尾部添加元素，+：数组头部添加元素，冒号靠近的地方就是我们运算先开始的地方

3. 第二种方式定义数组

val arr1 = Array(1, 2)

（1）在定义数组时，直接赋初始值
（2）使用apply方法创建数组对象

案例实操 ```scala object TestArray { def main(args: Array[String]): Unit = { var arr02 = Array(1, 3, “bobo”) println(arr02.length) for (i <- arr02) { println(i) } } }

<a name="DDKHY"></a>
## 迭代器
```scala
val arr2 = Array(12, 37, 42, 58, 97)
println(arr)
val iter = arr2.iterator
while (iter.hasNext)
println(iter.next())

foreach方法

arr2.foreach( (elem: Int) => println(elem) )

arr.foreach( println )

println(arr2.mkString("--"))

合并数组

以下实例中，我们使用 concat() 方法来合并两个数组，concat() 方法中接受多个数组参数：

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = Array(1.9, 2.9, 3.4, 3.5)
      var myList2 = Array(8.9, 7.9, 0.4, 1.5)

      var myList3 =  concat( myList1, myList2)

      // 输出所有数组元素
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

输出
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

创建区间数组

以下实例中，我们使用了 range() 方法来生成一个区间范围内的数组。range() 方法最后一个参数为步长，默认为 1：

import Array._

object Test {
   def main(args: Array[String]) {
      var myList1 = range(10, 20, 2)
      var myList2 = range(10,20)

      // 输出所有数组元素
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

输出
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Scala 数组方法

下表中为 Scala 语言中处理数组的重要方法，使用它前我们需要使用 import Array._ 引入包。

序号	方法和描述
1	*def apply( x: T, xs: T ): Array[T]** 创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。
2	def concatT: Array[T] 合并数组
3	def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit 复制一个数组到另一个数组上。相等于 Java’s System.arraycopy(src, srcPos, dest, destPos, length)。
4	def empty[T]: Array[T] 返回长度为 0 的数组
5	def iterateT( f: (T) => T ): Array[T] 返回指定长度数组，每个数组元素为指定函数的返回值。以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1： scala> Array.iterate(0,3)(a=>a+1) res1: Array[Int] = Array(0, 1, 2)
6	def fillT(elem: => T): Array[T] 返回数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
7	def fillT( elem: => T ): Array[Array[T]] 返回二数组，长度为第一个参数指定，同时每个元素使用第二个参数进行填充。
8	def ofDimT: Array[T] 创建指定长度的数组
9	def ofDimT: Array[Array[T]] 创建二维数组
10	def ofDimT: Array[Array[Array[T]]] 创建三维数组
11	def range( start: Int, end: Int, step: Int ): Array[Int] 创建指定区间内的数组，step 为每个元素间的步长
12	def range( start: Int, end: Int ): Array[Int] 创建指定区间内的数组
13	def tabulateT(f: (Int)=> T): Array[T] 返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。以上实例返回 3 个元素： scala> Array.tabulate(3)(a => a + 5) res0: Array[Int] = Array(5, 6, 7)
14	def tabulateT( f: (Int, Int ) => T): Array[Array[T]] 返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。

数组转字符串

val z = new Array[String](3)

    val a1 = z.mkString
    println(a1) // nullnullnull

    val a2 = z.mkString("[", ",", "]")
    println(a2) // [null,null,null]

字符串转数组

因为scala中的String复用了Java的String，因此这也是Java中String.split的用法。
split函数主要有两种参数形式：

def split(arg0: String): Array[String]
def split(arg0: String, arg1: Int): Array[String]

我们可以将第一种参数形式看作是默认arg1=0的第二种形式，即调用split(StrToSplit)等同于调用了split(StrToSplit, 0)。
因此，我将主要介绍第二种参数形式。第二种参数形式中每个参数的意义如下：
arg0: String 是一个正则表达式，代表分割的边界。这个正则表达式成功匹配一次，split的结果中就会加入一个新的子串。子串包含上次匹配后（如果没有上次匹配就是被分割字符串的起始位置）到这次匹配前的所有字符。最后，split函数会将最后一次匹配后剩余的字串作为最后一个子串加入到结果中。
arg1: Int 是对分割后子串的个数的限定。理解这个参数才能正确的运用split函数。
当arg1大于0时，它限制arg0最多成功匹配arg1-1次，也就是说字符串最多被分成arg1个子串。此时split会保留分割出的空字符串（当两个arg0连续匹配活着arg0在头尾匹配，会产生空字符串），直到达到匹配上限。比如:

scala> "a-b-c".split("-", 2)
res38: Array[String] = Array(a, b-c)

scala> "a-b-c".split("-", 4)
res39: Array[String] = Array(a, b, c)

scala> "-a-b-c--".split("-", 3)
res40: Array[String] = Array("", a, b-c--)

scala> "-a-b-c--".split("-", 6)
res41: Array[String] = Array("", a, b, c, "", "")

scala> "-a-b-c--".split("-", 5)
res42: Array[String] = Array("", a, b, c, -)

scala> "-a-b-c--".split("-", 8)
res43: Array[String] = Array("", a, b, c, "", "")

可变数组ArrayBuffer

数组-变长数组(声明泛型)

ArrayBuffer是变长数组，类似java的ArrayList
val arr2 = ArrayBuffer[Int]() 也是使用的 apply 方法构建对象
def append(elems: A*) { appendAll(elems) } 接收的是可变参数.
每 append 一次，arr 在底层会重新分配空间，进行扩容，arr2 的内存地址会发生变化，也就成为新的ArrayBuffer
定义变长数组
```
val arr01 = ArrayBuffer[Any](3, 2, 5)
```
（1）[Any]存放任意数据类型
（2）(3, 2, 5)初始化好的三个元素
（3）ArrayBuffer需要引入scala.collection.mutable.ArrayBuffer
案例实操

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

object TestArrayBuffer {
  def main(args: Array[String]): Unit = {
    //创建并初始赋值可变数组
    val arr01 = ArrayBuffer[Any](1, 2, 3)

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

    //追加数据
    arr01.+=(4)
    //向数组最后追加数据
    arr01.append(5, 6)
    //向指定的位置插入数据
    arr01.insert(0, 7, 8)
    println("arr01.hash=" + arr01.hashCode())

    //修改元素
    arr01(1) = 9 
    println("--------------------------")

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

输出结果：
1
2
3
3
arr01.hash=387518613
arr01.hash=-253706129
--------------------------
7
9
1
2
3
4
5
6
8

添加元素

val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
arr1.append(36)
arr1.prepend(11, 76)
arr1.insert(1, 13, 59)
println(arr1)   // ArrayBuffer(11, 13, 59, 76, 36)

val newArr1 = arr1 :+ 15
println(arr1)     // ArrayBuffer(11, 13, 59, 76, 36)
println(newArr1)    // ArrayBuffer(11, 13, 59, 76, 36, 15)
println(arr1 == newArr1)  // false

arr1.append(36)     // 末尾添加元素
arr1.prepend(11, 76)   // 头部添加 ArrayBuffer(11, 76, 11, 13, 59, 76, 36, 36)
arr1.insert(1, 13, 59)    // 找索引1的位置上插入 13, 59
println(arr1)     // ArrayBuffer(11, 13, 59, 76, 11, 13, 59, 76, 36, 36)

arr1.insertAll(2, newArr1)    // ArrayBuffer(11, 13, 11, 13, 59, 76, 36, 15, 59, 76, 11, 13, 59, 76, 36, 36)
arr1.prependAll(newArr1)

println(arr1)   // ArrayBuffer(11, 13, 59, 76, 36, 15, 11, 13, 11, 13, 59, 76, 36, 15, 59, 76, 11, 13, 59, 76, 36, 36)

删除方法

val arr1: ArrayBuffer[Int] = new ArrayBuffer[Int]()
arr1.append(36)
arr1.prepend(11, 76)
arr1.insert(1, 13, 59)
println(arr1)   // ArrayBuffer(11, 13, 59, 76, 36)

arr1.remove(3)
println(arr1)   //  ArrayBuffer(11, 13, 59, 36)

arr1.remove(0, 2) //从0索引位置开始删除2个
println(arr1)   // ArrayBuffer(59, 36)

arr1 -= 36 // 删除值等于36的, 如果值没出现就什么都不删
println(arr1) //ArrayBuffer(59, 36)

Array和ArrayBuffer转化

说明 ```scala arr1.toBuffer //不可变数组转可变数组 arr2.toArray //可变数组转不可变数组

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

2. **案例实操**
```scala
object TestArrayBuffer {
  def main(args: Array[String]): Unit = {
    //创建一个空的可变数组
    val arr2 = ArrayBuffer[Int]()

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

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

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

    println(newArr2)
  }
}

多维数组

多维数组定义
```
val arr = Array.ofDim[Double](3,4)
```
说明：二维数组中有三个一维数组，每个一维数组中有四个元素
案例实操 ```scala object DimArray { def main(args: Array[String]): Unit = { //创建了一个二维数组, 有三个元素，每个元素是，含有4个元素一维数组() val arr = Array.ofDimInt arr(1)(2) = 88 array(1)(0) = 25

//遍历二维数组 println(array.mkString(“, “)) for (i <- 0 until array.length; j <- 0 until array(i).length){ println(array(i)(j)) } for (i <- array.indices; j <- array(i).indices){ print(array(i)(j) + “\t”) if (j == array(i).length - 1) println() }

array.foreach(line => line.foreach(println))

array.foreach(_.foreach(println)) } }

```scala
import Array._

object Test {
   def main(args: Array[String]) {
      val myMatrix = Array.ofDim[Int](3, 3)

      // 创建矩阵
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }

      // 打印二维阵列
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }

   }
}

输出
0 1 2
0 1 2
0 1 2