English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Scala 数组

Arrays, die in Scala bereitgestellt werden, dienen dazu, eine festgelegte Anzahl von Elementen desselben Typs zu speichern und sind eine der wichtigsten Datenstrukturen für jede Programmiersprache.

Die Deklaration eines Array-Variables ist nicht die Deklaration von number0, number1、...、number99 Anstatt eine einzelne Variable zu deklarieren, wird eine Variable wie numbers deklariert, dann wird numbers[0]、numbers[1]、...、numbers[99] um eine einzelne Variable zu repräsentieren. Ein spezifisches Element im Array wird durch den Index erreicht.

Der erste Elementindex des Arrays ist 0, der Index des letzten Elements ist die Gesamtzahl der Elemente minus1。

Array deklarieren

Hier ist das Syntaxformat für die Array-Deklaration in Scala:

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

In dieser Grammatik wird mit 'z' ein Array vom Typ String deklariert, dessen Länge ist 3 ,kann gespeichert werden 3 Stellen Sie für jedes Element einen Wert fest und greifen Sie über die Indizes auf jedes Element zu, wie folgt:

z(0) = "w3codebox"; z(1) = "Baidu"; z(4/2) = "Baidu"; z(

) = "Google" 4/2 Als Index, ähnlich wie z(2) = "Google"

Wir können auch auf die folgende Weise ein Array definieren:

var z = Array("w3codebox", "Baidu", "Google")

Das Diagramm zeigt ein Array mit einer Länge von 10 des Arrays myList, Index 0 bis 9:

Verarbeiten Sie das Array

Die Elementtypen und die Größe der Arrays sind festgelegt, daher verwenden wir in der Regel einfache for-Schleifen, um mit den Arrayelementen umzugehen.

Das folgende Beispiel zeigt den Prozess der Erstellung, Initialisierung und Verarbeitung von Arrays:

object Test {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // 输出所有数组元素
      for ( x <- myList ) {
         println( x )
      }
      // Berechnen Sie die Summe aller Elemente im Array
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Die Summe beträgt " + total);
      // Finden Sie das größte Element im Array
      var max = myList(0);
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      println("Der größte Wert ist " + max);
    
   }
}

执行以上代码,输出结果为:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
Die Summe beträgt 11.7
Der größte Wert ist 3.5

Mehrdimensionale Arrays

Mehrdimensionale Arrays können Werte eines Arrays sein, und die Werte eines anderen Arrays können ebenfalls ein Array sein. Matrizen und Tabellen sind unsere gängigen zweidimensionalen Arrays.

Hier ist ein Beispiel für die Definition eines zweidimensionalen Arrays:

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

Im Beispiel enthält das Array drei Array-Elemente, und jedes Array-Element enthält wiederum drei Werte.

Nun schauen wir uns ein vollständiges Beispiel für die Verarbeitung von zweidimensionalen Arrays an:

import Array._
object Test {
   def main(args: Array[String]) {
      val myMatrix = Array.ofDim[Int](3, 3)
      
      // Erstellen Sie ein Matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Drucken Sie das zweidimensionale Array aus
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
    
   }
}

执行以上代码,输出结果为:

$ scalac Test.scala
$ scala Test
0 1 2
0 1 2
0 1 2

合并数组

In den folgenden Beispielen verwenden wir die concat() -Methode, um zwei Arrays zu kombinieren. Die concat() -Methode akzeptiert mehrere Array-Parameter:

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)
      
      // 输出所有数组元素
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

执行以上代码,输出结果为:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

创建区间数组

以下示例中,我们使用了 range() 方法来生成一个区间范围内的数组。range() 方法的最后一个参数为步长,默认为 1:

import Array._
object Test {
   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 )
      }
   }
}

执行以上代码,输出结果为:

$ scalac Test.scala
$ scala Test
10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

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 的 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]]

: 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 开始。