Scala详解---------数组相关操作

Scala中提供了一种数据结构-数组，其中存储相同类型的元素的固定大小的连续集合。数组用于存储数据的集合，但它往往是更加有用认为数组作为相同类型的变量的集合。

取替声明单个变量，如number0, number1, ..., 和number99，声明一个数组变量，如号码和使用numbers[0]，numbers[1]，...，numbers[99]表示单个变量。本教程介绍了如何声明数组变量，创建数组和使用索引的过程变量数组。数组的第一个元素的索引是数字0和最后一个元素的索引为元素的总数减去1。

声明数组变量：

要使用的程序的数组，必须声明一个变量来引用数组，必须指定数组变量可以引用的类型。下面是语法声明数组变量：

var z:Array[String] = new Array[String](3)

or

var z = new Array[String](3)

在这里，z被声明为字符串数组，最多可容纳三个元素。可以将值分配给独立的元素或可以访问单个元素，这是可以做到通过使用类似于以下命令：

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

在这里，最后一个例子表明，在一般的索引可以是产生一个全数字的表达式。定义数组还有另一种方式：

var z = Array("Zara", "Nuha", "Ayan")

下图展示了数组myList。在这里，myList中拥有10个double值,索引是从0到9。

处理数组：

当要处理数组元素，我们经常使用循环，因为所有的数组中的元素具有相同的类型，并且数组的大小是已知的。这里是展示如何创建，初始化和处理数组的完整的例子：

object Test {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }

      // Summing all elements
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      // Finding the largest element
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("Max is " + max);
    
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

C:/>scalac Test.scala
C:/>scala Test
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

C:/>

多维数组：

有很多情况下，需要定义和使用多维数组（即数组的元素数组）。例如，矩阵和表格结构的实例可以实现为二维数组。

Scala不直接支持多维数组，并提供各种方法来处理任何尺寸数组。以下是定义的二维数组的实例：

var myMatrix = ofDim[Int](3,3)

这是一个具有每个都是整数，它有三个元素数组3元素的数组。下面的代码展示了如何处理多维数组：

import Array._

object Test {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
    
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

C:/>scalac Test.scala
C:/>scala Test
0 1 2
0 1 2
0 1 2

C:/>

联接数组：

以下是使用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)
      
      // Print all the array elements
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

C:/>scalac Test.scala
C:/>scala Test
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

C:/>

创建具有范围数组：

下面是示例，这使得使用range() 方法来产生包含在给定的范围内增加整数序列的数组。可以使用最后一个参数创建序列; 如果不使用最后一个参数，然后一步将被假定为1。

import Array._

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

      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

让我们编译和运行上面的程序，这将产生以下结果：

C:/>scalac Test.scala
C:/>scala Test
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

C:/>

Scala中数组方法：

以下是重要的方法，可以同时使用数组。如上所示，则必须使用任何提及的方法之前，要导入Array._包。有关可用方法的完整列表，请Scala中的官方文件。

SN	方法及描述
1	def apply( x: T, xs: T* ): Array[T] 创建T对象，其中T可以是Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean数组。
2	def concat[T]( xss: Array[T]* ): Array[T] 连接所有阵列成一个数组。
3	def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit 复制一个数组到另一个。相当于Java的System.arraycopy(src, srcPos, dest, destPos, length).
4	def empty[T]: Array[T] 返回长度为0的数组
5	def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] 返回一个包含一个函数的重复应用到初始值的数组。
6	def fill[T]( n: Int )(elem: => T): Array[T] 返回包含某些元素的计算的结果的次数的数组。
7	def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] 返回一个二维数组，其中包含某些元素的计算的结果的次数。
8	def iterate[T]( start: T, len: Int)( f: (T) => T ): Array[T] 返回一个包含一个函数的重复应用到初始值的数组。
9	def ofDim[T]( n1: Int ): Array[T] 创建数组给出的尺寸。
10	def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建了一个2维数组
11	def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建3维数组
12	def range( start: Int, end: Int, step: Int ): Array[Int] 返回包含一些整数间隔等间隔值的数组。
13	def range( start: Int, end: Int ): Array[Int] 返回包含的范围内增加整数序列的数组。
14	def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回包含一个给定的函数的值超过从0开始的范围内的整数值的数组。
15	def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回一个包含给定函数的值超过整数值从0开始范围的二维数组。

数组相关操作

摘要:

本篇主要学习如何在Scala中操作数组。Java和C++程序员通常会选用数组或近似的结构（比如数组列表或向量）来收集一组元素。在Scala中，我们的选择更多，不过现在我们先假定不关心其他选择，而只是想马上开始用数组。本篇的要点包括：

1. 若长度固定则使用Array，若长度可能有变化则使用ArrayBuffer

2. 提供初始值时不要使用new

3. 用()来访问元素

4. 用for (elem<-arr)来遍历元素

5. 用for (elem<-arr if…)…yield…来将原数组转型为新数组

6. Scala数组和java数组可以互操作；用AnayBuffer，使用scalacollection.JavaConversions中的转换函数

定长数组

如果你需要一个长度不变的数组，可以用Scala中的Array。例如：

val nums=new Array[Int] (10) //长度为10的整数数组，所有元素初始化为0

val a=new Array [String] (10) //长度为10的字符串数组，所有元素初始化为null

val s= Array("Hello", "World") //长度为2的Array[String]类型是推断出来的，已提供初始值就不需要new

S (0) ="Goodbye" //Array（"Goodby "，"World"）,使用()而不是[]来访问元素

在JVM中，Scala的Array以Java数组方式实现。示例中的数组在JVM中的类型为java.lang.String[]。Int、Double或其他与Java中基本类型对应的数组都是基本类型数组。

举例来说，Array(2，3，5，7，11)在JVM中就是一个int[]。

变长数组：缓冲

尾端操作缓冲数组
对于那种长度按需要变化的数组，Java有ArrayList，C++有vector。Scala中的等效数据结构为ArrayBuffer

import scala.collection.mutable.ArrayBuffer

val b=ArrayBuffer[lnt]() // 或者new ArrayBuffer [int]，一个空的数组缓冲，准备存放整数

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) //用++=操作符追加任何集合

b.trimEnd(5) // ArrayBuffer(1, 1, 2)，移除最后5个元素

在数组缓冲的尾端添加或移除元素是一个高效的操作

任意位置操作缓冲数组
你也可以在任意位置插入或移除元素，但这样的操作并不那么高效。所有在那个位置之后的元素，都必须被平移。举例如下：

b.insert (2,6) //ArrayBuffer(1, 1,
6, 2)，在下标2之前插入

b.insert (2,7,8,9) // ArrayBuffer(1, 1,7,8,9, 6,2)，你可以插入任意多的元素

b.remove(2) // ArrayBuffer(1,1,8,9,6,2)

b.remove (2,3) //ArrayBuffer(1,1, 2)，第2个参数的含义是要移除多少个元素

有时你需要构建一个Array，但不知道最终需要装多少元素。在这种情况下，先构建一个数组缓冲，然后调用：

b.toArray //Array(1, 1，2)
反过来，调用乱toBuffer可以将一个数组a转换成一个数组缓冲

遍历数组和数组缓冲

全遍历
在Java和C++中，数组和数组列表／向量有一些语法上不同，Scala则更加统一。大多数时候，你可以用相同的代码处理这两种数据结构。以下是for循环遍历数组或数组缓冲的语法：

for (i <- 0 until a.length) //变量i的取值从0到a length -1

println(i+"："+a(i))

utiI是Richlnt类的方法，返回所有小于但不包括上限的数字。例如：

0 until 10 // Range(0,1,2,3,4,5,6,7,8, 9)
需要注意的是，0 until 10实际上是一个方法调用：0.until(10)

条件遍历
如下结构：

for(I <- 区间)
会让变量i遍历该区间的所有值。拿本例来说，循环变量i先后取值0、1，等等，直到但不包含a.length。如果想要每两个元素一跳，可以让i这样来进行遍历：

0 until (a.length,2) //Range(0,2,4,…)
如果要从数组的尾端开始，遍历的写法为：

(0 until a.length) .reverse //Range(...,2,1,0)
如果在循环体中不需要用到数组下标，我们也可以直接访问数组元素，就像这样：

for (elem <- a)

println (elem)

这和Java中的"增强版"for循环，或者C++中的"基于区间的"for循环很相似。变量elem先后被设为a(0)，然后a(1)，依此类推

数组转换

for中的推导式和守卫
在前面，你看到了如何像Java或C++那样操作数组。不过在Scala中，你可以走得更远。从一个数组或数组缓冲出发，以某种方式对它进行转换是很简单的。这些转换动作不会修改原始数组，而是产生一个全新的数组。像这样使用for推导式：

val a=Array(2, 3, 5, 7, 11)

val result=for (elem <- a)yield 2*elem //result是Array(4,6,10, 14, 22)

for(…)yield循环创建了一个类型与原始集合相同的新集合。如果你从数组出发，那么你得到的是另一个数组。如果你从数组缓冲出发，那么你在for(…)yield之后得到的也

是数组缓冲

结果包含yield之后的表达式的值，每次迭代对应一个。通常，当你遍历一个集合时，你只想处理那些满足特定条件的元素。这个需求可以通过守卫：for中的if来实现。在这里我们对每个偶数元素翻倍，并丢掉奇数元素：

for (elem <- a if elem%==0) yield 2*elem
请留意结果是个新的集合，原始集合并没有受到影响

一种等价方法
除上述之外，还有另一种做法是

a.filter (_%2==0).map(2*_)
甚至

a.filter { _%2 == 0 } map {2*_ }
某些有着函数式编程经验的程序员倾向于使用filter和map而不是守卫和yield，这不过是一种风格罢了与for循环所做的事完全相同。你可以根据喜好任意选择。

高效数组操作
考虑如下示例：给定一个整数的数组缓冲，我们想要移除除第一个负数之外的所有负数。传统的依次执行的解决方案会在遇到第一个负数时置一个标记，然后移除后续出现的负数元素

var first=true

var n=a.length

var i=0

while ( i<n ) {

if (a(i) >= 0)
i+=1
else{
if (first) {
first=false
i+=1
} else {
a.remove (i)
n-=1
}
}
}

但这个方案其实并不那么好：从数组缓冲中移除元素并不高效，把非负数值拷贝到前端要好得多。

首先收集需要保留的下标：

var first= true

val indexes=for (i <- 0 until a.length if first || a(i)>=0) yield {

if (a(i)<0)
first=false;
i
}

然后将元素移动到该去的位置，并截断尾端：

for(j <- 0 until indexes.length)

a(j)= a(indexes(j))
a.trimEnd (a.length -indexes.length)

这里的关键点是，拿到所有下标好过逐个处理

常用算法

求和与排序
有一种说法，很大比例的业务运算不过是在求和与排序。还好Scala有内建的函数来处理这些任务

Array(1,7,2, 9).sum // 19，对ArrayBuffer同样适用
要使用sum方法，元素类型必须是数值类型：要么是整型，要么是浮点数或者Biglnteger/BigDecimal。

同理，min和max输出数组或数组缓冲中最小和最大的元素。

ArraryBuffer("Mary", "had","a","little", "lamb").max // "little"
sorted方法将数组或数组缓冲排序并返回经过排序的数组或数组缓冲，这个过程并不会修改原始版本：

val b=ArrayBuffer(1,7,2, 9)

val bSorted=b.sorted(_ < _) // b没有被改变，bSorted是ArrayBuffer(1,2,7,9)

还可以提供一个比较函数，不过你需要用sortWith方法：

val bDescending=b.sorted(_ > _) // ArrayBuffer(9,7,2, 1)
可以直接对一个数组排序，但不能对数组缓冲排序：

val a=Array(1,7,2,9)

scala.util. Sorting.quickSortIa(a) // a现在是Array(1,2,7,9)

关于num、max和quickSort方法，元素类型必须支持比较操作，这包括了数字、字符串以及其他带有Ordered特质的类型。

显示数组内容
最后，如果你想要显示数组或数组缓冲的内容，可以用mkString方法，它允许你指定元素之间的分隔符。该方法的另一个重载版本可以让你指定前缀和后缀。例如:

a.mkString("and") // "1 and 2 and 7 and 9"

a.mkString("<" , "," , ">") // "<1,2,7,9>"

和toString相比：

a.toString // " [I@85b8d"，这里被调用的是Java的毫无意义的toString方法

b.toString // "ArrayBuffer(l,7,2, 9)"，toString方法报告了类型，便于调试

解读Scaladoc

数组和数组缓冲有许多有用的方法，我们可以通过浏览Scala文档来获取这些信息。对Array类的操作方法列在ArrayOps相关条目下。从技术上讲，在数组上应用这些操作之前，数组都会被转换成ArrayOps对象。

由于Scala的类型系统比java更丰富，在浏览Scala的文档时，你可能会遇到一些看上去很奇怪的语法。所幸，你并不需要理解类型系统的所有细节就可以完成很多有用

的工作。你可以把下表用做"解码指环"。

多维数组

和Java一样，多维数组是通过数组的数组来实现的。举例来说，Double的二维数组类型为：

Array[Array[Double]]
要构造这样一个数组，可以用ofDim方法：

val matrix=Array.ofDim[Double](3,4) //三行，四列要访问其中的元素，使用两对圆括号：

matrix (row) (column) =42

你可以创建不规则的数组，每一行的长度各不相同：

val triangle=new ArraylArray [Int] (10)

for (i <- 0 until triangle.length)

triangle(i)=new Array[lnt] (i+1)

与Java互操作

由于Scala数组是用java数组实现的，你可以在Java和Scala之间来回传递。如果你调用接受或返回java.utiI.List的Java方法，则当然可以在Scala代码中使用Java的ArrayList但那样做没什么意思。你完全可以引入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] = pb.command() // Java到Scala的转换

需要注意的是，不能使用ArrayBuffer——包装起来的对象仅能保证是个Buffer。如果Java方法返回一个包装过的Scala缓冲，那么隐式转换会将原始的对象解包出来。拿本例来说，cmd == command

本文借鉴文章：
http://www.yiibai.com/scala/scala_arrays.html http://www.cnblogs.com/sunddenly/p/4411564.html