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

object Test {
   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

import Array._

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

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)
     
      // 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

import Array._

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.

Autres extensions