Scala - Tableaux

Scala fournit une structure de données, le array, qui stocke une collection séquentielle de taille fixe d'éléments du même type. Un tableau est utilisé pour stocker une collection de données, mais il est souvent plus utile de considérer un tableau comme une collection de variables du même type.

Au lieu de déclarer des variables individuelles, telles que nombre0, nombre1, ... et nombre99, vous déclarez une variable de tableau telle que des nombres et utilisez les nombres [0], les nombres [1] et ..., les nombres [99] pour représenter variables individuelles. Ce didacticiel explique comment déclarer des variables de tableau, créer des tableaux et traiter des tableaux à l'aide de variables indexées. L'index du premier élément d'un tableau est le nombre zéro et l'indice du dernier élément est le nombre total d'éléments moins un.

Déclaration des variables de tableau

Pour utiliser un tableau dans un programme, vous devez déclarer une variable pour référencer le tableau et vous devez spécifier le type de tableau auquel la variable peut faire référence.

Voici la syntaxe pour déclarer une variable de tableau.

Syntaxe

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

or

var z = new Array[String](3)

Ici, z est déclaré comme un tableau de chaînes pouvant contenir jusqu'à trois éléments. Les valeurs peuvent être attribuées à des éléments individuels ou accéder à des éléments individuels, cela peut être fait en utilisant des commandes comme les suivantes -

Commander

z(0) = "Zara"; z(1) = "Nuha"; z(4/2) = "Ayan"

Ici, le dernier exemple montre qu'en général, l'index peut être n'importe quelle expression qui donne un nombre entier. Il existe une autre façon de définir un tableau -

var z = Array("Zara", "Nuha", "Ayan")

L'image suivante représente un tableau myList. Ici,myList contient dix valeurs doubles et les indices vont de 0 à 9.

Traitement des tableaux

Lors du traitement des éléments d'un tableau, nous utilisons souvent des structures de contrôle de boucle car tous les éléments d'un tableau sont du même type et la taille du tableau est connue.

Voici un exemple de programme montrant comment créer, initialiser et traiter des tableaux -

Exemple

object Demo {
   def main(args: Array[String]) {
      var myList = Array(1.9, 2.9, 3.4, 3.5)
      
      // Print all the array elements
      for ( x <- myList ) {
         println( x )
      }

      // Summing all elements
      var total = 0.0;
      
      for ( i <- 0 to (myList.length - 1)) {
         total += myList(i);
      }
      println("Total is " + total);

      // Finding the largest element
      var max = myList(0);
      
      for ( i <- 1 to (myList.length - 1) ) {
         if (myList(i) > max) max = myList(i);
      }
      
      println("Max is " + max);
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5

Scala ne prend pas directement en charge diverses opérations sur les tableaux et fournit diverses méthodes pour traiter les tableaux dans n'importe quelle dimension. Si vous souhaitez utiliser les différentes méthodes, il est nécessaire d'importerArray._ paquet.

Tableaux multidimensionnels

Il existe de nombreuses situations où vous auriez besoin de définir et d'utiliser des tableaux multidimensionnels (c'est-à-dire des tableaux dont les éléments sont des tableaux). Par exemple, les matrices et les tableaux sont des exemples de structures qui peuvent être réalisées sous forme de tableaux bidimensionnels.

Voici un exemple de définition d'un tableau à deux dimensions -

var myMatrix = ofDim[Int](3,3)

Il s'agit d'un tableau qui a trois éléments chacun étant un tableau d'entiers qui a trois éléments.

Essayez l'exemple de programme suivant pour traiter un tableau multidimensionnel -

Exemple

import Array._

object Demo {
   def main(args: Array[String]) {
      var myMatrix = ofDim[Int](3,3)
      
      // build a matrix
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            myMatrix(i)(j) = j;
         }
      }
      
      // Print two dimensional array
      for (i <- 0 to 2) {
         for ( j <- 0 to 2) {
            print(" " + myMatrix(i)(j));
         }
         println();
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

0 1 2
0 1 2
0 1 2

Concaténer les tableaux

Essayez l'exemple suivant qui utilise la méthode concat () pour concaténer deux tableaux. Vous pouvez passer plus d'un tableau comme arguments à la méthode concat ().

Exemple

import Array._

object Demo {
   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)
      
      // Print all the array elements
      for ( x <- myList3 ) {
         println( x )
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

1.9
2.9
3.4
3.5
8.9
7.9
0.4
1.5

Créer un tableau avec une plage

Utilisation de la méthode range () pour générer un tableau contenant une séquence d'entiers croissants dans une plage donnée. Vous pouvez utiliser l'argument final comme étape pour créer la séquence; si vous n'utilisez pas d'argument final, l'étape sera considérée comme 1.

Prenons un exemple de création d'un tableau de plage (10, 20, 2): cela signifie créer un tableau avec des éléments entre 10 et 20 et une différence de plage 2. Les éléments du tableau sont 10, 12, 14, 16 et 18 .

Autre exemple: range (10, 20). Ici, la différence de plage n'est pas donnée donc par défaut, elle suppose 1 élément. Il crée un tableau avec les éléments compris entre 10 et 20 avec une différence de plage 1. Les éléments du tableau sont 10, 11, 12, 13,… et 19.

L'exemple de programme suivant montre comment créer un tableau avec des plages.

Exemple

import Array._

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

      // Print all the array elements
      for ( x <- myList1 ) {
         print( " " + x )
      }
      
      println()
      for ( x <- myList2 ) {
         print( " " + x )
      }
   }
}

Enregistrez le programme ci-dessus dans Demo.scala. Les commandes suivantes sont utilisées pour compiler et exécuter ce programme.

Commander

\>scalac Demo.scala
\>scala Demo

Production

10 12 14 16 18
10 11 12 13 14 15 16 17 18 19

Méthodes de tableau Scala

Voici les méthodes importantes que vous pouvez utiliser tout en jouant avec un tableau. Comme indiqué ci-dessus, vous devrez importerArray._package avant d'utiliser l'une des méthodes mentionnées. Pour une liste complète des méthodes disponibles, veuillez consulter la documentation officielle de Scala.

Sr. Non Méthodes avec description
1

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

Crée un tableau d'objets T, où T peut être Unit, Double, Float, Long, Int, Char, Short, Byte, Boolean.
2

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

Concatène tous les tableaux en un seul tableau.
3

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

Copiez un tableau dans un autre. Équivalent à System.arraycopy de Java (src, srcPos, dest, destPos, length).
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 contenant des applications répétées d'une fonction à une valeur de départ.
6

def fill[T]( n: Int )(elem: => T): Array[T]

Renvoie un tableau qui contient les résultats de certains calculs d'éléments un certain nombre de fois.
sept

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

Renvoie un tableau à deux dimensions qui contient les résultats de certains calculs d'éléments un certain nombre de fois.
8

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

Renvoie un tableau contenant des applications répétées d'une fonction à une valeur de départ.
9

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

Crée un tableau avec des dimensions données.
dix

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

Crée un tableau à 2 dimensions
11

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

Crée un tableau en 3 dimensions
12

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

Renvoie un tableau contenant des valeurs également espacées dans un intervalle entier.
13

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

Renvoie un tableau contenant une séquence d'entiers croissants dans une plage.
14

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

Renvoie un tableau contenant les valeurs d'une fonction donnée sur une plage de valeurs entières à partir de 0.
15

def tabulate[T]( n1: Int, n2: Int )( f: (Int, Int ) => T): Array[Array[T]]

Renvoie un tableau à deux dimensions contenant les valeurs d'une fonction donnée sur des plages de valeurs entières à partir de 0.
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved