Indépendament du langage de programmation, un tableau peut être vu comme un ensemble de variables de même type, auxquelles on peut accéder individuellement par le nom du tableau et un indice. Les "variables" qui constituent le tableau sont appelées les éléments du tableau.
Un tableau est donc défini par le type de ses éléments et sa taille, c'est à dire le nombre d'éléments qu'il contient.
Par contre, la manière de déclarer un tableau et de noter l'indicage des élements dépend fortement du langage de programmation. Nous allons présenter ici celle du langage Java.
Voici une manière de déclarer un tableau en Java
type nom du tableau [] = new type [taille];
où type désigne le type des éléments du tableau. Donc avec les types que nous avons vus jusque là, nous pouvons définir de cette manière un tableau constitué d'éléments de type int:
int nom du tableau [] = new int [taille];
ou double:
double nom du tableau [] = new double [taille];
ou String:
String nom du tableau [] = new String [taille];
ou boolean:
boolean nom du tableau [] = new boolean [taille];
Notez bien que le type des éléments peut varier d'un tableau à l'autre, mais tous les éléments d'un même tableau sont forcément du même type.
Une petite remarque avant d'aller plus loin. La manière de déclarer un tableau que je vous présente ici pourra vous paraitre étrange. Pourquoi faut-il préciser deux fois le type des éléments ? que signifie le mot clé new ? Vous trouverez, la réponse à ces questions dans le premier cours consacré à la programmation objet où d'autres manières de déclarer un tableau seront présentées.
De manière générale, la taille qui figure dans la déclaration d'un tableau est une expression de type int. Pour fixer les idées, voici différentes manières de déclarer un tableau de taille 10:
type nom du tableau [] = new type [10];
mais cela fonctionne aussi si Taille est une variable de type int valant 10:
int Taille = 10; type nom du tableau [] = new type [Taille];
où bien une constante valant 10:
final int Taille = 10; type nom du tableau [] = new type [Taille];
Mais quelque soit la manière de déclarer la taille, gardez à l'esprit qu'elle ne pourra plus être modifiée par la suite (c'est à dire au cours de l'exécution du programme, si le tableau est une variable globale, ou au cours de l'exécution du sous-programme dans lequel il est déclaré, s'il s'agit d'une variable locale).
Chaque élément d'un tableau est indicé, c'est à dire qu'il possède un numéro qui permet de le repérer à l'intérieur du tableau.
En Java, l'indicage des éléments d'un tableau commence forcément à 0. Le premier élément d'un tableau T se note donc T[0] et non pas T[1] !
Cela a une deuxième conséquence : le dernier élément d'un tableau de taille N, n'est pas T[N] mais T[N-1].
Par exemple avec un tableau T de taille 3, le dernier élément sera T[2].
Les indices des éléments d'un tableau de taille N varient donc entre 0 et N-1. Si l'on tente d'accéder à un élément en dehors de ces limites (par exemple par T[N] ou T[-1]), on obtient une erreur d'exécution.
Les opérations que l'on effectue sur les tableaux utilisent fréquemment des boucles dans lesquelles on parcours tous les éléments entre deux indices pour les traiter individuellement. Ce type de boucle peut s'écrire comme suit:
int i, imin, imax;
i = imin;
while (i <= imax)
{
Traitement à effectuer
sur l'élément d'indice i
i++;
}
imin désigne ici l'indice du premier élément à traiter et imax celui du dernier.
Au lieu d'utiliser une boucle while pour ceci, on utilise généralement un autre type de boucle dont je n'ai pas encore parlé: la boucle for.
Pour commencer, voilà la syntaxe de la boucle for:
for ( initialisation; condition; post-traitement) instructions à répéter
Les instructions à répéter doivent figurer entre accolades, s'il y en a plusieurs. S'il n'y en a qu'une seule, elle doit être suivie d'un point-virgule.
La partie initialisation sert à donner des valeurs initiales aux variables de la boucle. On y trouve donc en général des affections (très souvent, l'initialisation du compteur de la boucle ). S'il y en a plusieurs, elles doivent être séparées par les virgules (et non pas des point-virgules comme d'habitude). Les instructions figurant dans la partie initialisation seront exécutées avant le démarrage de la boucle.
Comme dans la boucle while:
La seule différence est que vous n'êtes pas obligé de mettre la condition entre parenthèses.
Le post-traitement est un ensemble d'instructions qui seront exécutées à la fin de chaque itération. On y trouve très souvent l'incrémentation du compteur. S'il y a plusieurs instructions, il faut les séparer par des virgules.
Pour en revenir aux tableaux, la boucle permettant de traiter tous les éléments entre deux indices s'écrit comme suit avec for:
int i, imin, imax;
for (i = imin; i <= imax; i++)
{
Traitement à effectuer
sur l'élément d'indice i
}
Cette écriture vous permettra d'éviter d'écrire des accolades lorsqu'il n'y a qu'une seule instructions à répéter. Par exemple, avec un tableau T de taille 10, la boucle suivante:
int i; for (i = 0; i <= 9; i++) T[i]=0;
initialise tous les éléments du tableau à 0.
Avec une boucle while, il faut mettre des accolades, initialiser le compteur avant la boucle et incrémenter le compteur à l'intérieur:
int i;
i = 0;
while (i <=0)
{
T[i]=0;
i++;
}
à vous de choisir!
Je précise pour terminer que la boucle for n'est pas spécifique au traitement des tableaux. Elle est aussi générale que la boucle while. Je l'ai simplement présentée dans ce paragraphe pour des raisons pédagogiques.
Dans certaines situations, les éléments d'un tableau doivent être initialisés avec des valeurs arbitraires distinctes ou qui ne peuvent pas se déduire simplement de leurs indices. Dans ce cas on ne pourra pas initialiser le tableau par une boucle, mais il faudra mettre les valeurs une à une en utilisant autant d'affectations qu'il y a d'éléments dans le tableau.
Prenons un exemple. On souhaiterait disposer d'un tableau T contenant les noms des six couleurs "rouge", "orange", "jaune", "vert", "bleu", "violet".
Il faudrait donc déclarer T comme un tableau de chaine de caractères de taille 6, puis utiliser six affectations pour obtenir les valeurs souhaitées:
String T[] = new String[6]; T[0]="rouge"; T[1]="orange"; T[2]="jaune"; T[3]="vert"; T[4]="bleu"; T[5]="violet";
Java a prévu un raccourci d'écriture pour ce genre de situation. Le code précédent par exemple peut s'écrire:
String T[] = {"rouge", "orange", "jaune",
"vert", "bleu", "violet" };
Nous avons donc ici une deuxième manière de déclarer un tableau. De manière générale elle pourrait s'écrire:
type nom du tableau [] = {valeur1 , valeur2 ,..., valeurN};
où valeur1, valeur2, ..., valeurN sont des expressions de même type que le tableau.
Notez bien que lorsque vous déclarez un tableau de cette manière, la taille du tableau est déduite du nombre de valeurs contenues dans les accolades.