Scala Arrays

Die in der Sprache Scala bereitgestellten Arrays werden verwendet, um Elemente fester Größe des gleichen Typs zu speichern. Arrays sind eine der wichtigen Datenstrukturen für jede Programmiersprache.

Das Deklarieren einer Array-Variable bedeutet nicht, einzelne Variablen wie number0, number1, ..., number99 nacheinander zu deklarieren, sondern eine Variable wie numbers zu deklarieren und dann numbers zu verwenden

Der Index des ersten Elements eines Arrays ist 0, und der Index des letzten Elements ist die Gesamtzahl der Elemente minus 1.


Arrays deklarieren

Das Folgende ist das Syntaxformat für Scala-Array-Deklarationen:

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

或

var z = new Array[String](3)

In der obigen Syntax deklariert z ein Array vom Typ String mit der Länge 3, das 3 Elemente speichern kann. Wir können für jedes Element einen Wert festlegen und auf jedes Element über seinen Index zugreifen, wie unten gezeigt:

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

Der Index des letzten Elements verwendet den Ausdruck4/2als Index, ähnlich wiez(2) = "Google"。

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

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

Die folgende Abbildung zeigt ein Array myList der Länge 10 mit Indexwerten von 0 bis 9:


Verarbeitung von Arrays

Die Elementtypen und die Größe eines Arrays sind festgelegt, daher verwenden wir bei der Verarbeitung von Array-Elementen normalerweise eine einfache for-Schleife.

Das folgende Beispiel demonstriert den Vorgang des Erstellens, Initialisierens und Verarbeitens eines Arrays:

Beispiel

object Test {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
     
      // Alle Array-Elemente ausgeben
      for ( x <- myList ) {
         println( x )
      }

      // Die Summe aller Array-Elemente berechnen
      var total = 0.0;
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println(Summe = + total);

      // Finde 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(Max = + max);
   
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

$ scalac Test.scala
$ scala Test
1.9
2.9
3.4
3.5
总和为 11.7
最大值为 3.5

Mehrdimensionale Arrays

In mehrdimensionalen Arrays können die Werte in einem Array ein weiteres Array sein, und die Werte eines anderen Arrays können ebenfalls ein Array sein. Matrizen und Tabellen sind übliche zweidimensionale Arrays.

Das Obige ist ein Beispiel, das ein zweidimensionales Array definiert:

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

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

Als Nächstes sehen wir uns ein vollständiges Beispiel für die Verarbeitung eines zweidimensionalen Arrays an:

Beispiel

import Array._

object Test {
   def main(args: Array[String]) {
      val myMatrix = Array.ofDim[Int](3, 3)
     
      // Eine Matrix erstellen
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
     
      // Das zweidimensionale Array ausgeben
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

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

Arrays verketten

Im folgenden Beispiel verwenden wir die concat()-Methode, um zwei Arrays zu verketten. Die concat()-Methode akzeptiert mehrere Array-Parameter:

Beispiel

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)
     
      // Alle Array-Elemente ausgeben
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

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

Erstellen von Range-Arrays

Im folgenden Beispiel verwenden wir die Methode range(), um ein Array innerhalb eines Bereichs zu erzeugen. Der letzte Parameter der Methode range() ist der Schritt, der standardmäßig 1 ist:

Beispiel

import Array._

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

      // Alle Array-Elemente ausgeben
      for ( x <- myList1 ) {
         print( " " + x )
      }
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Das Ausführen des obigen Codes erzeugt die folgende Ausgabe:

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

Scala-Array-Methoden

Die folgende Tabelle listet die wichtigen Methoden für den Umgang mit Arrays in Scala auf. Bevor wir sie verwenden, müssen wirimport Array._verwenden, um das Paket zu importieren.

Nein. Methode und Beschreibung
1

def apply( x: T, xs: T* ): Array[T]

Erstellt ein Array des angegebenen Typs T; T kann Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean sein.

2

def concat[T]( xss: Array[T]* ): Array[T]

Verkettet Arrays

3

def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit

Kopiert ein Array in ein anderes. Entspricht Javas System.arraycopy(src, srcPos, dest, destPos, length).

4

def empty[T]: Array[T]

Gibt ein Array der Länge 0 zurück

5

def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T]

Gibt ein Array der angegebenen Länge zurück, wobei jedes Element der Rückgabewert der angegebenen Funktion ist.

Im obigen Beispiel hat das Array einen Anfangswert von 0, eine Länge von 3, und die Berechnungsfunktion ista=>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]

Gibt ein Array zurück, dessen Länge durch den ersten Parameter angegeben wird und bei dem jedes Element mit dem zweiten Parameter gefüllt wird.

7

def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]]

Gibt ein zweidimensionales Array zurück, dessen Länge durch den ersten Parameter angegeben wird und bei dem jedes Element mit dem zweiten Parameter gefüllt wird.

8

def ofDim[T]( n1: Int ): Array[T]

Erzeugt ein Array mit der angegebenen Länge

9

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

Erzeugt ein zweidimensionales Array

10

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

Erzeugt ein dreidimensionales Array

11

def range( start: Int, end: Int, step: Int ): Array[Int]

Erzeugt ein Array innerhalb des angegebenen Bereichs, wobei step die Schrittweite zwischen den einzelnen Elementen ist

12

def range( start: Int, end: Int ): Array[Int]

Erzeugt ein Array innerhalb des angegebenen Bereichs

13

def tabulate[T]( n: Int )(f: (Int)=> T): Array[T]

Gibt ein Array der angegebenen Länge zurück, wobei jedes Element der Rückgabewert der angegebenen Funktion ist, standardmäßig beginnend bei 0.

Im obigen Beispiel werden 3 Elemente zurückgegeben:

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

Gibt ein zweidimensionales Array der angegebenen Länge zurück, wobei jedes Element der Rückgabewert der angegebenen Funktion ist und standardmäßig bei 0 beginnt.

Andere Erweiterungen