要点先知
- 若长度固定，则使用
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)
参考
- 《快学Scala》
