Tableaux Scala

Les tableaux fournis par le langage Scala sont utilisés pour stocker des éléments de type homogène de taille fixe, les tableaux sont l'un des structures de données importantes pour chaque langage de programmation.

Déclarer une variable tableau n'est pas déclarer number0, number1、...、number99 Au lieu de déclarer des variables individuelles, une variable comme numbers est déclarée, puis utilisez numbers[0]、numbers[1]、...、numbers[99] pour représenter des variables individuelles. Un élément spécifique du tableau est accédé via l'index.

L'index du premier élément du tableau est 0, l'index du dernier élément est le nombre total d'éléments moins1。

Déclaration de tableau

Voici le format de syntaxe de déclaration de tableau en Scala :

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

Dans cette syntaxe, z déclare un tableau de type chaîne, la longueur du tableau est 3 ，peut stocker 3 éléments. Nous pouvons définir une valeur pour chaque élément et accéder à chaque élément par l'index, comme suit :

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

) = "Google" 4/2 comme index, similaire à z(2) = "Google"。

Nous pouvons également définir un tableau de la manière suivante :

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

L'image suivante montre un tableau de longueur 10 du tableau myList, l'index est de 0 à 9：

Traitement du tableau

Les types d'éléments des tableaux et la taille des tableaux sont déterminés, donc lors du traitement des éléments du tableau, nous utilisons généralement un boucle for de base.

Voici un exemple de création, d'initialisation et de traitement des tableaux :

object　Test　{
　　　def　main(args:　Array[String])　{
　　　　　　var　myList　=　Array(1.9,　2.9,　3.4,　3.5)
　　　　　　
　　　　　　//　Affiche tous les éléments du tableau
　　　　　　for　(　x　<-　myList　)　{
　　　　　　　　　println(　x　)
　　　　　　}
　　　　　　//　Calcul de la somme de tous les éléments du tableau
　　　　　　var　total　=　0.0;
　　　　　　for　(　i　<-　0　to　(myList.length　-　1))　{
　　　　　　　　　total　+=　myList(i);
　　　　　　}
　　　　　　println("La somme est　"　+　total);
　　　　　　//　Recherche de l'élément maximal du tableau
　　　　　　var　max　=　myList(0);
　　　　　　for　(　i　<-　1　to　(myList.length　-　1)　)　{
　　　　　　　　　if　(myList(i)　>　max)　max　=　myList(i);
　　　　　　}
　　　　　　println("La valeur maximale est　"　+　max);
　　　　
　　　}
}

Exécutez le code suivant, le résultat est :

$　scalac　Test.scala
$　scala　Test
1.9
2.9
3.4
3.5
La somme est　11.7
La valeur maximale est　3.5

Tableau multidimensionnel

Un tableau multidimensionnel peut contenir un autre tableau comme valeur, et la valeur d'un autre tableau peut également être un tableau. La matrice et le tableau sont des tableaux bidimensionnels courants que nous utilisons souvent.

Voici un exemple de définition d'un tableau bidimensionnel :

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

Dans cet exemple, le tableau contient trois éléments d'array, chaque élément d'array contient trois valeurs.

Voici un exemple complet de traitement d'un tableau bidimensionnel :

import　Array._
object　Test　{
　　　def　main(args:　Array[String])　{
　　　　　　val　myMatrix　=　Array.ofDim[Int](3,　3)
　　　　　　
　　　　　　//　Création de la matrice
　　　　　　for　(i　<-　0　to　2)　{
　　　　　　　　　for　(　j　<-　0　to　2)　{
　　　　　　　　　　　　myMatrix(i)(j)　=　j;
　　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　//　Affichage de la matrice bidimensionnelle
　　　　　　for　(i　<-　0　to　2)　{
　　　　　　　　　for　(　j　<-　0　to　2)　{
　　　　　　　　　　　　print("　"　+　myMatrix(i)(j));
　　　　　　　　　}
　　　　　　　　　println();
　　　　　　}
　　　　
　　　}
}

Exécutez le code suivant, le résultat est :

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

Fusionne des tableaux

Dans cet exemple, nous utilisons la méthode concat() pour fusionner deux tableaux, la méthode concat() accepte plusieurs paramètres de tableaux :

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)
　　　　　　
　　　　　　//　Affiche tous les éléments du tableau
　　　　　　for　(　x　<-　myList3　)　{
　　　　　　　　　println(　x　)
　　　　　　}
　　　}
}

Exécutez le code suivant, le résultat est :

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

Crée un tableau de plage

Dans les exemples ci-dessous, nous avons utilisé la méthode range() pour générer un tableau dans une plage de valeurs. La dernière valeur du paramètre de la méthode range() est l'incrément, par défaut il est de 1：

import　Array._
object　Test　{
　　　def　main(args:　Array[String])　{
　　　　　　var　myList1　=　range(10,　20,　2)
　　　　　　var　myList2　=　range(10,20)
　　　　　　//　Affiche tous les éléments du tableau
　　　　　　for　(　x　<-　myList1　)　{
　　　　　　　　　print(　"　"　+　x　)
　　　　　　}
　　　　　　println()
　　　　　　for　(　x　<-　myList2　)　{
　　　　　　　　　print(　"　"　+　x　)
　　　　　　}
　　　}
}

Exécutez le code suivant, le résultat est :

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

Méthodes des tableaux Scala

Dans le tableau suivant, sont présentées les méthodes importantes pour traiter les tableaux en Scala, avant d'utiliser lesquelles nous devons utiliser import Array._ Introduire le paquet.

scala>　Array.iterate(0,3)(a=>a+1)
res1:　Array[Int]　=　Array(0,　1,　2)

scala>　Array.tabulate(3)(a　=>　a　+　5)
res0:　Array[Int]　=　Array(5,　6,　7)