要点先知

• 若长度固定，则使用Array，若长度可能 有变化则使用ArrayBuffer
• 提供初始值时不要使用new
• 用()来访问元素
• 用for(elem <- arr)来遍历元素
• 用for(elem <- arr if ...)...yeild...来将原数组转型为新数组
• Scala数据和Java数组可以互操作，用ArrayBuffer，使用scala.collection.JavaConversions中的转换函数

定长数组

val nums = new Array[Int](10) // 10个整数型的数组，所有元素初始化为0
val s = new Array[String](10) // 10个字符串类型数组，初始化为null
val s = Array("Hello", "World") // 提供初始值时不要用new
s(0) = "Goodbye"// Array("Goodbye", "World"), 使用()非[]访问元素

变长数组

import scala.collection.mutable.ArrayBuffer
val b = new ArrayBuffer[Int]() // 因为没有初始化，所以new和()可以只要一个
// val b =  ArrayBuffer[Int]() or val b = new ArrayBuffer[Int]

// 用+=给b尾端添加元素
b += 1 // ArrayBuffer(1)
b += (1, 2, 3, 5) // ArrayBuffer(1, 1, 2, 3, 5)
// 用++=追加任何集合
b ++= Array(8, 13, 21) // ArrayBuffer(1, 1, 2, 3, 5, 8, 13, 21)
// 用.trimEnd(N) 移除最后N个元素, .trimStart(N)移除开始N个元素
b.trimEnd(5) // ArrayBuffer(1, 1, 2)

在数组缓冲的尾端添加或移除元素是一个高效的操作，你也可以在任意位置添加或移除元素，但这样的操作并不那么高效，因为所有在哪个位置之后的元素都必须被平移。

// b.insert(pos, nums), 在pos位置之前插入nums
b.insert(2, 6, 7, 8) // ArrayBuffer(1, 1, 6, 7, 8, 2)
// b.remove(pos, lens = 1), 从pos位置开始，移除lens个元素
b.remove(2) // ArrayBuffer(1, 1, 7, 8, 2)
b.remove(2, 3) // ArrayBuffer(1, 1)

有时需要构建一个Array, 但不知道最终要装多少个元素。在这种情况下，先构建一个数组缓冲，然后调用：
b.toArray。然过来，调用a.toBuffer可以将一个数组a转换成一个数组缓冲。

遍历数组

• 数组的长度：a.length
• 遍历数据index：0 until a.length // 0 until 3, Range(0, 1, 2)
• 遍历偶数index：0 until (a.length, 2)
• 从尾端开始遍历：(0 until a.length).reverse

数组装换

使用for(x <- arr)yield func(x) 可以把arr数组做map函数转换

val a = Array(1, 2, 3, 4)
val result = for(elem <- a) yield 2 * elem // result = Array(2, 4, 6, 8)
// 效果等同：val result = a.map(2 * _) // _是a中元素的迭代器

常用算法

可以在Scala API文档查看Array和ArrayBuffer的常用方法

多维数组

多维数组是通过数组的数组实现的，Double的二维数组类型为Array[Array[Double]]

// 构建3行4列的矩阵
val matrix = Array.ofDim[Double](3, 4) // matrix的每个元素初始化为0.0
// 元素访问：matrix(row)(col)
matrix(0)(0) = 1

不规则数组

val triangle = new Array[Array[Int]](5) // triangle的每个元素初始化为null
for(i <- 0 until triangle.length){
    triangle(i) = new Array[Int](i + 1) // triangle(i)的每个元素初始化为0
}

与Java的互操作

Scala的数组是用Java数组实现的，所以可以在Scala和Java中来回传递。引入scala.collection.JavaConversions的隐式转换方法，这样在使用Scala缓冲，调用Java方法时，这些对象会被自动包装成Java列表。

在java.lang.ProcessBuilder类中有一个以List<String>为参数的构造器。在Scala中调用它的例子：

import scala.collection.JavaConversions.bufferAsJavaList
import scala.collection.mutable.ArrayBuffer
val command = ArrayBuffer("ls", "-al", "/home/cay")
val pb = new ProcessBuilder(command) // Scala到Java的转换

Scala缓冲被包装成了一个实现了java.util.List接口的Java类对象。反过来，当Java方法返回java.util.List时，我们可以让它自动转换成一个Buffer：

import scala.collection.JavaConversions.asScalaBuffer
import scala.collection.mutable.Buffer
val cmd: Buffer[String] = pd.command() // Java到Scala的转换
// 不能使用ArrayBuffer, 因为包装起来的对象仅能保证是个Buffer

练习

1. 编写一段代码，将a设置为一个n个随机整数的数组，要求随机数介于[0, n)

import scala.util.Random
val n = 10
val a = new Array[Int](n)
for(elem <- 0 until n){
    a(elem) = Random.nextInt(10)
}

2. 编写一个循环，将整数数组中相邻的数组置换。例如，Array(1, 2, 3, 4, 5)经过置换后变为Array(2, 1, 4, 3, 5)。

// 方法1
val a = Array(1, 2, 3, 4, 5)
for(i <- 0 until (a.length - 2, 2)){
    val t = a(i)
    a(i) = a(i + 1)
    a(i + 1) = t

}
// 方法2
val a = Array(1, 2, 3, 4, 5)
val result = new Array[Int](a.length)
for(i <- 0 until a.length){
    if(i == a.length - 1) {
        result(i) = a(i)
        }else if(i % 2 == 1){
            result(i) = a(i - 1)
            }else {
                result(i) = a(i + 1)
            }
}

3. 重复上一个练习，不过这一次生成一个新的值交换过的数组。用for/yield

val a = Array(1, 2, 3, 4, 5)
val result = new Array[Int](a.length)
// 先把下标置换好
val index = for(i <- 0 until a.length) yield {
     if(i == a.length - 1) {
       i
        }else if(i % 2 == 1){
            i - 1
            }else {
                i + 1
            }
        }
// 把置换好的下标给到result  
for(elem <- 0 until result.length){
    result(elem) = a(index(elem))
}

4. 给定一个整数数组，产出一个新的数组，包含原数组中的所有正值，以原有顺序排列，之后的元素是原有零或负数，以原有顺序排列。

val a = Array(1, -1, -3, 5, -5, -2, 0, 7)
val result = new ArrayBuffer[Int]()
// 两种方法: 1. 找到下标，再赋值 2. 直接赋值
// 此处只展示方法2
result ++= (for(i <- 0 until a.length if a(i) > 0) yield a(i))
result ++= (for(i <- 0 until a.length if a(i) <= 0) yield a(i))

5. 如何计算Array[Double]的平均值？

import scala.util.Random
val a = (Seq.fill(5)(Random.nextDouble * 10)).toArray // 生成5个10以内的随机double数
a.sum / a.length

6. 如何重新组织Array[Int]的元素将它们以反序排列？对于ArrayBuffer[Int]你优惠怎么做呢？

// Array, ArrayBuffer的语法一样
val a = Array(1, 2, 3, 4, 5)
val result = (for(i <- (0 until a.length).reverse) yield a(i)) // 返回的是Vector类型
// a.reverse

注：对于ArrayBuffer是否转换为Java List, 然后用Java.lang.util包的函数

7. 编写一段代码，产出数组中的所有值,去掉重复值。（提示：查看scaladoc）

val a = Array(1, 2, 3, 4, 5, 1, 1, 2, 3, 4)
a.distinct

**8. 重新编写3.4节结尾的示例。收集负值元素的下标，反序，去掉最后一个下标，然后对每一个下标调用a.remove(i)。比较这样做的效率和3.4节中另外两种方法的效率。

val a = ArrayBuffer(1, -1, -3, 5, -5, -2, 0, 7)
val result = (for(i <- 0 until a.length if a(i) < 0) yield i).reverse.dropRight(1)
for(i <- result) a.remove(i)

9. 创建一个由 java.util.TimeZone.getAvailableIDs返回的时区集合，判断条件是它们在美洲。去掉"America/"前缀并排序。

val sortedAmericanZone = java.util.TimeZone.getAvailableIDs.filter(_.startsWith("America")).map(_.replaceFirst("America/", "")).sorted
// Array、String通过filter和map等函数，结合起来无敌了

10. 引入 java.awt.datatransfer._ 并构建一个类型为 SystemFlavorMap 类型的对象： val flavors = SystemFlavorMap.getDefaultFlavorMap().asInstanceOf[SystemFlavorMap] 然后以 DataFlavor.imageFlavor 为参数调用 getNativesForFlavor 方法，以 Scala 缓冲保存返回值。

import java.awt.datatransfer._
import scala.collection.JavaConversions._
import scala.collection.mutable.Buffer
val flavors = SystemFlavorMap.getDefaultFlavorMap().asInstanceOf[SystemFlavorMap]
val flavor: Buffer[String] = flavors.getNativesForFlavor(DataFlavor.imageFlavor)

参考

1. 《快学Scala》