Module 1.
6 : Les tableaux
Comme tout langage de programmation qui se respecte, Java travaille avec des
tableaux. Vous verrez que ceux-ci s'avèrent bien pratiques.
Tableau à une dimension
Comme nous l'avons vu auparavant, une variable d'un type donné ne peut contenir
que des éléments de ce type : une variable de type int ne peut pas recevoir une
chaîne de caractères. Il en va de même pour les tableaux. Voyons tout de suite
comment ils se déclarent :
<type du tableau> <nom du tableau> [] = { <contenu du tableau>};
La déclaration ressemble beaucoup à celle d'une variable quelconque, si ce n'est la
présence de crochets « [ ] » après le nom de notre tableau et d'accolades « { } »
encadrant l'initialisation de celui-ci. Dans la pratique, ça nous donnerait quelque
chose comme ceci :
int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};
Vous remarquez bien que la déclaration et l'initialisation d'un tableau se font comme
avec une variable ordinaire : il faut utiliser des « ' ' » pour initialiser un tableau de
caractères, des « " " » pour initialiser un tableau de String, etc. Vous pouvez aussi
déclarer un tableau vide, mais celui-ci devra impérativement contenir un nombre de
cases bien défini. Par exemple, si vous voulez un tableau vide de six entiers :
int tableauEntier[] = new int[6];
//Ou encore
int[] tableauEntier2 = new int[6];
Cette opération est très simple, car vraiment ressemblante à ce que vous faisiez
avec vos variables ; je vous propose donc tout de suite de nous pencher sur une
belle variante de ces tableaux…
Les tableaux multidimensionnels
Ici, les choses se compliquent un peu, car un tableau multidimensionnel n'est rien
d'autre qu'un tableau contenant au minimum deux tableaux… Je me doute bien que
cette notion doit en effrayer plus d'un, mais en réalité, elle n'est pas si difficile que ça
à appréhender. Comme tout ce que je vous apprends en général !
Je ne vais pas vous faire de grand laïus sur ce type de tableau, puisque je pense
sincèrement qu'un exemple vous en fera beaucoup mieux comprendre le concept.
Imaginez un tableau avec deux lignes : la première contiendra les premiers nombres
pairs, et le deuxième contiendra les premiers nombres impairs.
Ce tableau s'appellera premiersNombres. Voilà ce que cela donnerait :
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };
Nous voyons bien ici les deux lignes de notre tableau symbolisées par les doubles
crochets [ ][ ]. Et comme je l'ai dit plus haut, ce genre de tableau est composé de
plusieurs tableaux. Ainsi, pour passer d'une ligne à l'autre, nous jouerons avec la
valeur du premier crochet. Exemple : premiersNombres[0][0] correspondra au
premier élément de la ligne paire, et premiersNombres[1][0] correspondra au
premier élément de la ligne impaire.
La figure suivante représente un petit schéma en guise de synthèse.
Comprendre un tableau
bidimensionnel
Maintenant, je vais vous proposer de vous amuser un peu avec les tableaux…
Utiliser et rechercher dans un tableau
Un tableau débute toujours à l'indice 0
Cela implique qu'un tableau contenant 4 éléments aura comme indices possibles 0,
1, 2 ou 3. Le 0 correspond au premier élément, le 1 correspond au 2e élément, le 2
correspond au 3e élément et le 3 correspond au 4e élément.
Taille du tableau : <mon tableau>.length. Notre boucle for pourrait donc
ressembler à ceci :
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
for(int i = 0; i < [Link]; i++)
{
[Link]("À l'emplacement " + i +" du tableau nous avons = " +
tableauCaractere[i]);
Cela affichera :
À l'emplacement 0 du tableau nous avons = a
À l'emplacement 1 du tableau nous avons = b
À l'emplacement 2 du tableau nous avons = c
À l'emplacement 3 du tableau nous avons = d
À l'emplacement 4 du tableau nous avons = e
À l'emplacement 5 du tableau nous avons = f
À l'emplacement 6 du tableau nous avons = g
Maintenant, nous allons essayer de faire une recherche dans un de ces tableaux. En
gros, il va falloir effectuer une saisie clavier et regarder si celle-ci est présente dans
le tableau… Gardez la partie de code permettant de faire plusieurs fois la même
action ; ensuite, faites une boucle de recherche incluant la saisie clavier, un
message si la saisie est trouvée dans le tableau, et un autre message si celle-ci
n'est pas trouvée. Ce qui nous donne :
char tableauCaractere[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
int i = 0;
char reponse = ' ',carac = ' ';
Scanner sc = new Scanner([Link]);
do {//Boucle principale
do {//On répète cette boucle tant que l'utilisateur n'a pas rentré une lettre figurant
dans le tableau
i = 0;
[Link]("Rentrez une lettre en minuscule, SVP ");
carac = [Link]().charAt(0);
//Boucle de recherche dans le tableau
while(i < [Link] && carac != tableauCaractere[i])
i++;
//Si i < 7 c'est que la boucle n'a pas dépassé le nombre de cases du tableau
if (i < [Link])
[Link](" La lettre " +carac+ " se trouve bien dans le tableau !");
else //Sinon
[Link](" La lettre " +carac+ " ne se trouve pas dans le tableau !");
}while(i >= [Link]);
//Tant que la lettre de l'utilisateur ne correspond pas à une lettre du tableau
do{
[Link]("Voulez-vous essayer à nouveau ? (O/N)");
reponse = [Link]().charAt(0);
}while(reponse != 'N' && reponse != 'O');
}while (reponse == 'O');
[Link]("Au revoir !");
Le résultat de ce code se trouve à la figure suivante.
Résultat de la recherche
En travaillant avec les tableaux, vous serez confrontés, un jour ou l'autre, au
message suivant :
[Link]
Ceci signifie qu'une erreur a été rencontrée, car vous avez essayé de lire (ou d'écrire
dans) une case qui n'a pas été définie dans votre tableau ! Voici un exemple (nous
verrons les exceptions lorsque nous aborderons la programmation orientée objet) :
String[] str = new String[10];
//L'instruction suivante va déclencher une exception
//Car vous essayez d'écrire à la case 11 de votre tableau
//Alors que celui-ci n'en contient que 10 (ça commence à 0 !)
str[10] = "Une exception";
Nous allons maintenant travailler sur le tableau bidimensionnel mentionné
précédemment. Le principe est vraiment identique à celui d'un tableau simple, sauf
qu'ici, il y a deux compteurs. Nous allons travailler sur un code permettant d'afficher
les données par ligne, c'est-à-dire l'intégralité du sous-tableau de nombres pairs,
puis le sous-tableau de nombres impairs.
Avec une boucle while
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }, i = 0, j = 0;
while (i < 2)
j = 0;
while(j < 5)
[Link](premiersNombres[i][j]);
j++;
[Link]("");
i++;
Le résultat se trouve à la figure suivante.
Affichage du tableau
Détaillons un peu ce code :
Dans un premier temps, on initialise les variables.
On entre ensuite dans la première boucle (qui s'exécutera deux fois,
donc i vaut 0 la première fois, et vaudra 1 pendant la deuxième), et on
initialise j à 0.
On entre ensuite dans la deuxième boucle, où j vaudra successivement 0,
1, 2, 3 et 4 pour afficher le contenu du tableau d'indice 0 (notre premier i).
On sort de cette boucle ; notre i est ensuite incrémenté et passe à 1.
On reprend le début de la première boucle : initialisation de j à 0.
On entre à nouveau dans la deuxième boucle, où le processus est le
même que précédemment (mais là, i vaut 1).
Enfin, nous sortons des boucles et le programme termine son exécution.
Le même résultat avec une boucle for
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };
for(int i = 0; i < 2; i++)
for(int j = 0; j < 5; j++)
[Link](premiersNombres[i][j]);
[Link]("");
Je vous avais parlé d'une nouvelle syntaxe pour cette boucle, la voici :
String tab[] = {"toto", "titi", "tutu", "tete", "tata"};
for(String str : tab)
[Link](str);
Ceci signifie qu'à chaque tour de boucle, la valeur courante du tableau est mise dans
la variable str. Vous constaterez que cette forme de boucle for est particulièrement
adaptée aux parcours de tableaux !
Attention cependant, il faut impérativement que la variable passée en premier
paramètre de la boucle for soit de même type que la valeur de retour du tableau
(une variable de type String pour un tableau de String, un int pour un tableau
d'int etc.).
Concernant les tableaux à deux dimensions, que va retourner l'instruction de la
première boucle for? Un tableau ! Nous devrons donc faire une deuxième boucle
afin de parcourir ce dernier !
Resumé
Un tableau est une variable contenant plusieurs données d'un même type.
Pour déclarer un tableau, il faut ajouter des crochets [ ] à la variable ou à
son type de déclaration.
Vous pouvez ajouter autant de dimensions à votre tableau que vous le
souhaitez, ceci en cumulant des crochets à la déclaration.
Le premier élément d'un tableau est l'élément 0.