Scala数组笔记

一、定长数组

Scala中定义长度不变的数组，采用如下方法：

//10个元素的数组，初始化为全0
scala> val nums = new Array[Int](10)
nums: Array[Int] = Array(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

//10个元素的字符串数组，初始化为全null
scala> val a = new Array[String](10)
a: Array[String] = Array(null, null, null, null, null, null, null, null, null, null)

//长度为2的字符串数组，类型推断得到
//此处已经提供初始值，不需要new
scala> val s = Array("Hello","World")
s: Array[String] = Array(Hello, World)

//通过()访问元素，更改值
scala> s(0) = "Goodbye"

scala> s
res1: Array[String] = Array(Goodbye, World)

二、变长数组：数组缓冲

Scala中用ArrayBuffer实现变长数组。

scala> import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.ArrayBuffer

//空的数组缓冲，存放整数
scala> val b = ArrayBuffer[Int]()  
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer()

//+=在尾端添加元素
scala> b += 1
res2: b.type = ArrayBuffer(1)

//在尾端添加多个元素
scala> b += (1, 2, 3, 5)
res3: b.type = ArrayBuffer(1, 1, 2, 3, 5)

//++=追加集合
scala> b ++= Array(8, 13, 21)
res4: b.type = ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21)

//移除最后5个元素
scala> b.trimEnd(5)

scala> b
res6: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2)

//在下标为2的前面插入元素6
scala> b.insert(2, 6)

scala> b
res8: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 6, 2)

//在下标为2的前面插入多个元素（7，8，9）
scala> b.insert(2, 7, 8, 9)

scala> b
res10: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 7, 8, 9, 6, 2)

//移除下标为2的元素
scala> b.remove(2)
res11: Int = 7

scala> b
res12: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 8, 9, 6, 2)

//移除从下标为2的元素起（包括下标为2的元素）的3个元素
scala> b.remove(2, 3)

scala> b
res14: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 1, 2)

//将可变数组转为不变数组
scala> b.toArray
res15: Array[Int] = Array(1, 1, 2)

//将不变数组转为可变数组
scala> b.toBuffer
res16: scala.collection.mutable.Buffer[Int] = ArrayBuffer(1, 1, 2)

三、遍历数组和数组缓冲

用for循环遍历数组或数组缓冲：

for (i <- 0 until a.length)  //i取值0到a.length-1，实际调用0.until(10)
    println(i + ": " + a(i))

//间隔元素遍历
0 until (a.length, 2)

//从数组尾端开始遍历
(0 until a.length).reverse

//忽略下标，直接访问数组元素
for (elem <- a) //变量elem依次被设为a(0),a(1)...
    println(elem)

四、数组转换

scala> val a = Array(2, 3, 5, 7, 11)
a: Array[Int] = Array(2, 3, 5, 7, 11)

//产生一个新的数组，数组元素对应为a中元素的2倍
scala> val result = for(elem <- a) yield 2 * elem
result: Array[Int] = Array(4, 6, 10, 14, 22)

如果我们只想处理满足一定条件的元素，可以使用守卫来实现。

//只对a中的偶数元素进行操作
scala> for (elem <- a if elem % 2 == 0) yield 2 * elem   
res17: Array[Int] = Array(4)

//函数式编程实现同样的操作
scala> a.filter(_ % 2 == 0).map(_ * 2)
res18: Array[Int] = Array(4)

五、常用算法

scala> Array(1, 7, 2, 9).sum  //sum方法，元素必须为数值类型，数值缓冲操作相同
res19: Int = 19

scala> Array(1, 7, 2, 9).max
res20: Int = 9

scala> Array(1, 7, 2, 9).min
res21: Int = 1

scala> ArrayBuffer("Marry", "had", "a", "little", "lamb").max
res22: String = little

scala> val b = ArrayBuffer(1, 7, 2, 9)
b: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 7, 2, 9)

//sorted方法对数组缓冲进行排序，返回排序后的新数组缓冲，原数组缓冲不变
 val bSorted = b.sorted
bSorted: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 2, 7, 9)

//如果要显示数组或数组缓冲的内容，使用mkString方法实现，指定元素间的分隔符
scala> b.mkString(" and ")
res29: String = 1 and 7 and 2 and 9

scala> b.mkString("<", ",", ">")
res30: String = <1,7,2,9>

//b转为不变数组a
scala> val a = b.toArray
a: Array[Int] = Array(1, 7, 2, 9)

//用函数对可变数组排序，报错
scala> scala.util.Sorting.quickSort(b)
<console>:10: error: overloaded method value quickSort with alternatives:
  (a: Array[Float])Unit <and>
  (a: Array[Int])Unit <and>
  [K](a: Array[K])(implicit evidence$1: scala.math.Ordering[K])Unit <and>
  (a: Array[Double])Unit
 cannot be applied to (scala.collection.mutable.ArrayBuffer[Int])
              scala.util.Sorting.quickSort(b)
                                 ^

//用函数对不变数组排序
scala> scala.util.Sorting.quickSort(a)

//函数可以对不变数组排序，但不能对数组缓冲排序
scala> a
res34: Array[Int] = Array(1, 2, 7, 9)

六、多维数组
多维数组通过数组的数组实现。例如Double类型的二维数组为Array[Array[Double]]。
也可以使用ofDim方法来构造数组：

scala> val matrix = Array.ofDim[Double](3, 4)   //三行四列
matrix: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0)) 

//使用(row)(column)访问元素
scala> matrix(0)(3) = 3.14

scala> matrix
res36: Array[Array[Double]] = Array(Array(0.0, 0.0, 0.0, 3.14), Array(0.0, 0.0, 0.0, 0.0), Array(0.0, 0.0, 0.0, 0.0))