无涯教程-Scala - 数组(Arrays)

时间:2024-01-26 15:56:46

Scala提供了一种数据结构数组 ,它存储了相同类型元素的固定大小的顺序集合。

声明数组

要在程序中使用数组,必须声明一个变量以引用该数组,并且必须指定该变量可以引用的数组的类型。

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 拥有十个双精度值,索引从0到9。

Scala Array

处理数组

在处理数组元素时,我们经常使用循环控制结构,因为数组中的所有元素都是相同的类型,并且数组的大小是已知的。

object Demo {
   def main(args: Array[String]) {
      var myList=Array(1.9, 2.9, 3.4, 3.5)
      
      //打印所有数组元素
      for ( x <- myList ) {
         println( x )
      }

      //对所有元素求和
      var total=0.0;
      
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      //找到最大的元素
      var max=myList(0);
      
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max=myList(i);
      }
      
      println("Max is " + max);
   }
}

将上述程序保存在 Demo.scala 中。以下命令用于编译和执行该程序。

\>scalac Demo.scala
\>scala Demo
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

多维数组

在许多情况下,您需要定义和使用多维数组(即,其元素为数组的数组)。如,矩阵和表格是可以实现为二维数组的结构的示例。

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

这是一个具有三个元素的数组,每个元素都是具有三个元素的整数数组。

import Array._

object Demo {
   def main(args: Array[String]) {
      var myMatrix=ofDim[Int](3,3)
      
      //建立一个矩阵
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j)=j;
         }
      }
      
      //打印二维数组
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

将上述程序保存在 Demo.scala 中。以下命令用于编译和执行该程序。

\>scalac Demo.scala
\>scala Demo
0 1 2
0 1 2
0 1 2

合并数组

请尝试以下示例,该示例利用concat()方法来连接两个数组,您可以将多个数组作为参数传递给concat()方法。

import Array._

object Demo {
   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)
      
      //打印所有数组元素
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

将上述程序保存在 Demo.scala 中。以下命令用于编译和执行该程序。

\>scalac Demo.scala
\>scala Demo
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Range创建数组

使用range()方法生成一个数组,该数组包含给定范围内的递增整数序列。您可以使用final参数作为创建序列的步骤,step默认为1。

让我们以创建范围为(10,20,2)的数组为例:这意味着创建一个数组,其元素之间的差值为10到20,步长为2。该数组中的元素为10、12、14、16和18。 

import Array._

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

      //打印所有数组元素
      for ( x <- myList1 ) {
         print( " " + x )
      }
      
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

将上述程序保存在 Demo.scala 中。以下命令用于编译和执行该程序。

\>scalac Demo.scala
\>scala Demo
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

数组方法

以下是重要的方法,您可以在使用数组时使用它们,如上所示,在使用任何上述方法之前,您必须导入 Array ._ 包。有关可用方法的完整列表,请查看Scala的官方文档。

Sr.No Methods with 描述
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]]

创建一个二维数组

11

def ofDim [T](n1:Int,n2:Int,n3:Int):Array [Array [Array [Array [T]]]

创建一个三维数组

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开始的整数值范围内。

参考链接

https://www.learnfk.com/scala/scala-arrays.html