Tableaux Scala
Les tableaux fournis dans le langage Scala sont utilisés pour stocker des éléments de taille fixe du même type. Les tableaux sont l'une des structures de données importantes pour chaque langage de programmation.
Déclarer une variable de tableau ne consiste pas à déclarer des variables individuelles comme number0, number1, ..., number99 une par une, mais plutôt à déclarer une variable telle que numbers, puis à utiliser numbers
L'indice du premier élément d'un tableau est 0, et l'indice du dernier élément est le nombre total d'éléments moins 1.
Déclarer des tableaux
Voici la syntaxe de déclaration des tableaux en Scala :
var z:Array[String] = new Array[String](3) 或 var z = new Array[String](3)
Dans la syntaxe ci-dessus, z déclare un tableau de type chaîne de longueur 3, pouvant stocker 3 éléments. Nous pouvons définir une valeur pour chaque élément et accéder à chaque élément via son index, comme indiqué ci-dessous :
z(0) = "Example"; z(1) = "Baidu"; z(4/2) = "Google"
L'index du dernier élément utilise l'expression4/2comme index, similaire àz(2) = "Google"。
Nous pouvons également définir un tableau de la manière suivante :
var z = Array("Example", "Baidu", "Google")
La figure suivante montre un tableau myList de longueur 10, avec des valeurs d'index de 0 à 9 :

Traitement des tableaux
Les types d'éléments et la taille d'un tableau sont fixes, donc lors du traitement des éléments d'un tableau, nous utilisons généralement une boucle for de base.
L'exemple suivant illustre le processus de création, d'initialisation et de traitement d'un tableau :
Exemple
def main(args: Array[String]) {
var myList = Array(1.9, 2.9, 3.4, 3.5)
// Afficher tous les éléments du tableau
for ( x <- myList ) {
println( x )
}
// Calculer la somme de tous les éléments du tableau
var total = 0.0;
for ( i <- 0 to (myList.length - 1)) {
total += myList(i);
}
println(Somme = + total);
// Trouver le plus grand élément du tableau
var max = myList(0);
for ( i <- 1 to (myList.length - 1) ) {
if (myList(i) > max) max = myList(i);
}
println(Max = + max);
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test 1.9 2.9 3.4 3.5 总和为 11.7 最大值为 3.5
Tableaux multidimensionnels
Dans les tableaux multidimensionnels, les valeurs d'un tableau peuvent être un autre tableau, et les valeurs d'un autre tableau peuvent aussi être un tableau. Les matrices et les tables sont des tableaux bidimensionnels courants.
Ce qui précède est un exemple qui définit un tableau à deux dimensions :
val myMatrix = Array.ofDim[Int](3, 3)
Dans l'exemple, le tableau contient trois éléments de tableau, et chaque élément de tableau contient trois valeurs.
Ensuite, examinons un exemple complet de traitement d'un tableau à deux dimensions :
Exemple
object Test {
def main(args: Array[String]) {
val myMatrix = Array.ofDim[Int](3, 3)
// Créer une matrice
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
myMatrix(i)(j) = j;
}
}
// Afficher le tableau à deux dimensions
for (i <- 0 to 2) {
for ( j <- 0 to 2) {
print(" " + myMatrix(i)(j));
}
println();
}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test 0 1 2 0 1 2 0 1 2
Concaténer des tableaux
Dans l'exemple suivant, nous utilisons la méthode concat() pour concaténer deux tableaux. La méthode concat() accepte plusieurs paramètres de tableau :
Exemple
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)
// Afficher tous les éléments du tableau
for ( x <- myList3 ) {
println( x )
}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test 1.9 2.9 3.4 3.5 8.9 7.9 0.4 1.5
Création de tableaux d'intervalles
Dans l'exemple suivant, nous utilisons la méthode range() pour générer un tableau dans un intervalle. Le dernier paramètre de la méthode range() est le pas, qui vaut 1 par défaut :
Exemple
object Test {
def main(args: Array[String]) {
var myList1 = range(10, 20, 2)
var myList2 = range(10,20)
// Afficher tous les éléments du tableau
for ( x <- myList1 ) {
print( " " + x )
}
println()
for ( x <- myList2 ) {
print( " " + x )
}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test 10 12 14 16 18 10 11 12 13 14 15 16 17 18 19
Méthodes de Array en Scala
Le tableau suivant répertorie les méthodes importantes pour manipuler les tableaux en Scala. Avant de les utiliser, nous devons utiliserimport Array._pour importer le package.
| Non. | Méthode et description |
|---|---|
| 1 |
def apply( x: T, xs: T* ): Array[T] Crée un tableau du type spécifié T ; T peut être Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean. |
| 2 |
def concat[T]( xss: Array[T]* ): Array[T] Concatène des tableaux |
| 3 |
def copy( src: AnyRef, srcPos: Int, dest: AnyRef, destPos: Int, length: Int ): Unit Copie un tableau dans un autre. Équivalent à System.arraycopy(src, srcPos, dest, destPos, length) de Java. |
| 4 |
def empty[T]: Array[T] Renvoie un tableau de longueur 0 |
| 5 |
def iterate[T]( start: T, len: Int )( f: (T) => T ): Array[T] Renvoie un tableau de la longueur spécifiée, où chaque élément est la valeur de retour de la fonction spécifiée. Dans l'exemple ci-dessus, le tableau a une valeur initiale de 0, une longueur de 3, et la fonction de calcul esta=>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] Renvoie un tableau dont la longueur est spécifiée par le premier paramètre, et chaque élément est rempli avec le deuxième paramètre. |
| 7 |
def fill[T]( n1: Int, n2: Int )( elem: => T ): Array[Array[T]] Renvoie un tableau à deux dimensions, dont la longueur est spécifiée par le premier paramètre, et chaque élément est rempli avec le deuxième paramètre. |
| 8 |
def ofDim[T]( n1: Int ): Array[T] Crée un tableau de la longueur spécifiée |
| 9 |
def ofDim[T]( n1: Int, n2: Int ): Array[Array[T]] Crée un tableau à deux dimensions |
| 10 |
def ofDim[T]( n1: Int, n2: Int, n3: Int ): Array[Array[Array[T]]] Crée un tableau à trois dimensions |
| 11 |
def range( start: Int, end: Int, step: Int ): Array[Int] Crée un tableau dans l'intervalle spécifié, step étant le pas entre chaque élément |
| 12 |
def range( start: Int, end: Int ): Array[Int] Crée un tableau dans l'intervalle spécifié |
| 13 |
def tabulate[T]( n: Int )(f: (Int)=> T): Array[T] Retourne un tableau de la longueur spécifiée, où chaque élément est la valeur de retour de la fonction spécifiée, en commençant par 0 par défaut. Dans l'exemple ci-dessus, il renvoie 3 éléments : 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]] Renvoie un tableau à deux dimensions de la longueur spécifiée, où chaque élément est la valeur de retour de la fonction spécifiée, en commençant par 0 par défaut. |