Scala-数组(2)

一维数组

• 先声明一个数组，再初始化

val array = new Array[Double](5) 

array: Array[Double] = Array(0.0, 0.0, 0.0, 0.0, 0.0)

array(0) = 1
array
res2: Array[Double] = Array(1.0, 0.0, 0.0, 0.0, 0.0)

赋值方式： array(index) = value

数组的索引是用圆括号

---

• 定义的同时初始化

var array = Array(1,2,3,4,5)

array: Array[Int] = Array(1, 2, 3, 4, 5)

---

• Array.fill(length)(value)方法

val array = Array.fill(5)(1,2,3,4,5)

array: Array[(Int, Int, Int, Int, Int)] = Array(
  (1, 2, 3, 4, 5),
  (1, 2, 3, 4, 5),
  (1, 2, 3, 4, 5),
  (1, 2, 3, 4, 5),
  (1, 2, 3, 4, 5)
)

val array1 = Array.fill(5)(1)

array1: Array[Int] = Array(1, 1, 1, 1, 1)

val array1 = Array.fill(5)(1,2)

array1: Array[(Int, Int)] = Array((1, 2), (1, 2), (1, 2), (1, 2), (1, 2))

如果 fill 第二个参数只写一个值的话，那么该数组的所有元素都是该值，但是如果第二个参数是一个 iterator 或者 random，那么数组就会被赋值为它们的值。

val array = Array.fill(2)(math.random)

array: Array[Double] = Array(0.30363272051348267, 0.6283708959751758)

---

• Array.ofDim[Double](dimension)

dimension 可以是一个数字，定义为一维数组，两个数字，定义为2维数组，最多可以定义为5维

val array = Array.ofDim[Double](1,2)

array: Array[Array[Double]] = Array(Array(0.0, 0.0))

array(0)(0) = 1
array

res11: Array[Array[Double]] = Array(Array(1.0, 0.0))

赋值方式： array(index) = value

---

变长数组

变长数组：指数组长度可以变化。

声明一个空的数组，此时数组没有任何元素，且不能以下标索引赋值：

import scala.collection.mutable.ArrayBuffer
val array = new ArrayBuffer[Int]()

import scala.collection.mutable.ArrayBuffer
array: ArrayBuffer[Int] = ArrayBuffer()

在数组尾部增加一个元素

println("增加元素之前的array: " + array)
array += 1
println("增加元素之后的array: " + array)

增加元素之前的array: ArrayBuffer()
增加元素之后的array: ArrayBuffer(1)

在数组尾部增加多个元素

println("增加元素之前的array: " + array)
array += (2,3,4)
println("增加元素之后的array: " + array)

增加元素之前的array: ArrayBuffer(1)
增加元素之后的array: ArrayBuffer(1, 2, 3, 4)

在数组尾部增加一个数组

println("增加数组之前的array: " + array)
array ++= Array(1,2)
println("增加数组之后的array: " + array)

增加数组之前的array: ArrayBuffer(1, 2, 3, 4)
增加数组之后的array: ArrayBuffer(1, 2, 3, 4, 1, 2)

在第index元素后插入一个元素

println("插入元素之前的array: " + array)
array.insert(2, 22)
println("插入元素之后的array: " + array)

插入元素之前的array: ArrayBuffer(1, 2, 3, 4, 1, 2)
插入元素之后的array: ArrayBuffer(1, 2, 22, 3, 4, 1, 2)

在第index元素后插入多个元素

println("插入元素之前的array: " + array)
array.insert(3, 33, 333)
println("插入元素之前的array: " + array)

插入元素之前的array: ArrayBuffer(1, 2, 22, 3, 4, 1, 2)
插入元素之前的array: ArrayBuffer(1, 2, 22, 33, 333, 3, 4, 1, 2)

移除第index元素后的n个元素

println("移除元素之前的array: " + array)
array.remove(4, 2)
println("移除元素之后的array: " + array)

移除元素之前的array: ArrayBuffer(1, 2, 22, 33, 333, 3, 4, 1, 2)
移除元素之后的array: ArrayBuffer(1, 2, 22, 33, 4, 1, 2)

---

多维数组

• 定长多维数组

第一种方式

val array = new Array[Array[Int]](length) 

val array = new Array[Array[Int]](5)

array: Array[Array[Int]] = Array(null, null, null, null, null)

array(0) = Array(1,2,3)
array

res3_1: Array[Array[Int]] = Array(Array(1, 2, 3), null, null, null, null)

第二种方式

ofDim[T](rows, column, height,...)

最多可以定义五维数组

val array = Array.ofDim[Int](2,3)

array: Array[Array[Int]] = Array(Array(0, 0, 0), Array(0, 0, 0))

• 变长多维数组

import scala.collection.mutable.ArrayBuffer
val arr1 = new ArrayBuffer[ArrayBuffer[Int]]()

import scala.collection.mutable.ArrayBuffer
arr1: ArrayBuffer[ArrayBuffer[Int]] = ArrayBuffer()

val arr2 = new ArrayBuffer[Int]()
arr2 += 1

arr2: ArrayBuffer[Int] = ArrayBuffer(1)
res16_1: ArrayBuffer[Int] = ArrayBuffer(1)

println("arr1 添加 ArrayBuffer之前:" + arr1)
arr1 += arr2
println("arr1 添加 ArrayBuffer之后:" + arr1)

arr1 添加 ArrayBuffer之前:ArrayBuffer()
arr1 添加 ArrayBuffer之后:ArrayBuffer(ArrayBuffer(1))

---

定长数组和变长数组的转换

• 定长数组imarray转换成变长数组array：

array = imarray.toBuffer

var imarray = Array(1,2,3,4,5)

imarray: Array[Int] = Array(1, 2, 3, 4, 5)

var array = imarray.toBuffer
array: collection.mutable.Buffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

• 变长数组array转换成定长数组imarray:

imarray = array.toArray

import scala.collection.mutable.ArrayBuffer
val array = new ArrayBuffer[Int]()

import scala.collection.mutable.ArrayBuffer
array: ArrayBuffer[Int] = ArrayBuffer()

array += (1,2,3,4,5)

res24: ArrayBuffer[Int] = ArrayBuffer(1, 2, 3, 4, 5)

imarray = array.toArray
imarray

res26_1: Array[Int] = Array(1, 2, 3, 4, 5)

• 当定/变长多维数组相互转换时，只转换最外面那层数组

val array = Array(Array(1,2),Array(3,4))

array: Array[Array[Int]] = Array(Array(1, 2), Array(3, 4))

array.toBuffer

res28: collection.mutable.Buffer[Array[Int]] = ArrayBuffer(Array(1, 2), Array(3, 4))

---

数组方法

使用它前我们需要使用 import Array._ 引入包。

• 合并数组 concat()

concat(array1,array2,array3,......)

用 concat() 方法来合并两个数组，concat() 方法中接受多个数组参数

import Array._
var array1 = Array(1,2,3,4,5)
var array2 = Array(6,7,8,9,10)
var array3 = Array(11,22)
var arrayConcat = concat(array1,array2,array3)

import Array._
array1: Array[Int] = Array(1, 2, 3, 4, 5)
array2: Array[Int] = Array(6, 7, 8, 9, 10)
array3: Array[Int] = Array(11, 22)
arrayConcat: Array[Int] = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 22

• 创建区间数组

range(start,end,step)

range() 方法来生成一个区间范围内的数组。range() 方法最后一个参数为步长，默认为 1：

import Array._
var a2 = range(2,5)
var a3 = range(2,10,2)


import Array._
a2: Array[Int] = Array(2, 3, 4)
a3: Array[Int] = Array(2, 4, 6, 8)

• apply方法

def apply( x: T, xs: T* ): Array[T]

创建指定对象 T 的数组, T 的值可以是 Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean。

var a = Array(1,2,3)

a: Array[Int] = Array(1, 2, 3)

我们看起来好像是作用在类 Array 上的，其实不然，而是作用在 Array 的伴生对象(object Array)上的，调用的是伴生对象 Array 的 apply 方法，即：

var a1 = Array.apply(1,2,3)

a1: Array[Int] = Array(1, 2, 3)

• copy

def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit

• src拷贝的源数组
• srcPos 拷贝源数组的开始位置
• dest 拷贝的目标数组
• destPos 拷贝的目标数组的开始位置
• length 拷贝的长度

就是从源数组src第srcPos位置开始拷贝length长度的元素插入到dest数组里destPos位置之后

var a = Array(1,1,1,1)
var b = Array(2,2,2,2,2)

a: Array[Int] = Array(1, 1, 1, 1)
b: Array[Int] = Array(2, 2, 2, 2, 2)

copy(a,1,b,2,2)

b

res54: Array[Int] = Array(2, 2, 1, 1, 2)

• empty

def empty[T]: Array[T]

返回长度为0的数组

var a = empty[Int]

a: Array[Int] = Array()