Scala 数组

Scala 数组

1、介绍

Scala 语言中提供的数组是用来存储固定大小的同类型元素。

使用 numbers[0]、numbers[1]、...、numbers[99] 来表示一个个单独的变量。

数组中某个指定的元素是通过索引来访问的。

数组的第一个元素索引为0，最后一个元素的索引为元素总数减1。

2、声明数组

(1）Scala 数组声明的语法格式：

var x:Array[String] = new Array[String](8)

或者
var x = new Array[String](8)

以上语法中，x 声明一个字符串类型的数组，数组长度为 8 ，可存储 8 个元素。我们可以为每个元素设置值，并通过索引来访问每个元素，如下所示：

x(0) = "I"; x(1) = "love"; x(4/2) = "Scala"

（2）还可以使用以下方式来定义一个数组：

var x = Array("I", "Love", "Scala")

3、处理数组

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本的 for 循环。

实例：

object Demo {
   def main(args: Array[String]) {
      var myDemoListt = Array(11.8, 12.8, 13.3, 13.4)
	  //var myDemoListt:Array[float] = new Array[float](4)
     
      // 输出所有数组元素
      for ( x <- myDemoListt ) {
         println( x )
      }

      // 计算数组所有元素的总和
      var totalSum = 0.0;
      for ( i <- 0 to (myDemoListt.length - 1)) {
         totalSum += myDemoListt(i);
      }
      println("总和=" + totalSum);

      // 查找数组中的最大元素
      var max = myDemoListt(0);
      for ( i <- 1 to (myDemoListt.length - 1) ) {
         if (myDemoListt(i) > max) max = myDemoListt(i);
      }
      println("最大值=" + max);
   
   }
}

11.8
12.8
13.3
13.4
总和=51.3
最大值=13.4

4、多维数组

多维数组一个数组中的值可以是另一个数组，另一个数组的值也可以是一个数组。矩阵与表格是我们常见的二维数组。

定义二维数组的实例：

val myMatrixDemo = Array.ofDim[Int](4, 3)

实例中数组中包含四个数组元素，每个数组元素又含有三个值。

二维数组处理的完整实例：

import Array._

object Demo {
   def main(args: Array[String]) {
      val myMatrixDemo = Array.ofDim[Int](4, 3)

      // 创建矩阵
      for (i <- 0 to 3) {
         for ( j <- 0 to 2) {
            myMatrixDemo(i)(j) = j;
         }
      }
     
      // 打印二维阵列
      for (i <- 0 to 3) {
         for ( j <- 0 to 2) {
            print(" " + myMatrixDemo(i)(j));
         }
         println();
      }
   }
}

 0 1 2
 0 1 2
 0 1 2
 0 1 2

5、合并数组

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

import Array._

object Demo {
   def main(args: Array[String]) {
      var list1 = Array(1, 2, 3, 4)
      var list2 = Array(8, 7, 6, 5)

      var list3 =  concat( list1, list2)
     
      // 输出所有数组元素
      for ( x <- list3 ) {
         println( x )
      }
   }
}

1
2
3
4
8
7
6
5

6、创建区间数组

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

import Array._

object Demo {
   def main(args: Array[String]) {
      var list1 = range(1, 10, 2)
      var list2 = range(1,10)

      // 输出所有数组元素
      for ( x <- list1 ) {
         print( " " + x )
      }
      println()
      for ( x <- list2 ) {
         print( " " + x )
      }
   }
}

 1 3 5 7 9
 1 2 3 4 5 6 7 8 9

7、Scala 数组方法

Scala 语言中处理数组的重要方法如下，使用它前我们需要使用 import Array._ 引入包：

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's 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] 返回指定长度数组，每个数组元素为指定函数的返回值。 以上实例数组初始值为 0，长度为 3，计算函数为a=>a+1： scala> Array.iterate(0,3)(a=>a+1) res1: Array[Int] = Array(0, 1, 2)
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 ofDim[T]( n1: Int ): Array[T] 创建指定长度的数组
9	def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] 创建二维数组
10	def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] 创建三维数组
11	def range( start: Int, end: Int, step: Int ): Array[Int] 创建指定区间内的数组，step 为每个元素间的步长
12	def range( start: Int, end: Int ): Array[Int] 创建指定区间内的数组
13	def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] 返回指定长度数组，每个数组元素为指定函数的返回值，默认从 0 开始。 以上实例返回 3 个元素： scala> Array.tabulate(3)(a => a + 5) res0: Array[Int] = Array(5, 6, 7)
14	def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]] 返回指定长度的二维数组，每个数组元素为指定函数的返回值，默认从 0 开始。