无涯教程-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

相关文章