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