Un tableau simple
Avant d'attaquer, je dois vous dire un truc
primordial (vous avez remarqué, c'est écrit en gros et en rouge).
Un tableau, comme ceux que nous avons fait ci-dessus, débute toujours à l'indice 0 !
Je m'explique : prenons l'exemple du tableau de caractères. Si vous voulez afficher la lettre '
a' à l'écran, vous devrez taper cette ligne de code :
Code : Java | System.out.println(tableauCaractere[0]);
|
Ce qui signifie tout bêtement qu'un tableau, ayant 4 éléments dans son contenu, aura comme entrées possibles
0, 1, 2 ou 3. Le 0 correspond au premier élément, le 1 correspond au 2° élément, le 2 correspond au 3° élément, et le 3 correspond au 4° élément.
Une très grande partie des erreurs sur les tableaux sont souvent dues à un mauvais indice dans celui-ci. Donc : prenez garde...
Ce que je vous propose, c'est tout bonnement d'afficher un des tableaux ci-dessus dans son intégralité. Et le premier qui me met ce code-là :
Code : Java | char tableauCaractere[] = {'a','b','c','d','e','f','g'};
System.out.println(tableauCaractere[0]);
System.out.println(tableauCaractere[1]);
System.out.println(tableauCaractere[2]);
System.out.println(tableauCaractere[3]);
|
... je l'
ASSASSINE ! Peut-être pas, quand même...
Il y a une manière beaucoup plus
classe, ou distinguée, mais surtout beaucoup plus pratique d'afficher le contenu d'un tableau.
Voici un parcours de tableau avec une boucle while
Code : Java | char tableauCaractere[] = {'a','b','c','d','e','f','g'};
int i = 0;
while (i < 4)
{
System.out.println("A l'emplacement " + i +" du tableau nous avons = " +tableauCaractere[i]);
i++;
}
|
Même résultat que précédemment, mais avec une boucle for (à utiliser de préférence)
Code : Java | char tableauCaractere[] = {'a','b','c','d','e','f','g'};
for(int i = 0; i < 4; i++)
{
System.out.println("A l'emplacement " + i +" du tableau nous avons = " +tableauCaractere[i]);
}
|
Euh... Comment fait-on si on ne connaît pas la taille de notre tableau à l'avance ?
Décidément, vous lisez dans mes pensées... J'allais y venir !
En fait, il existe une instruction qui retourne la taille d'un tableau.
Il s'agit de l'instruction
<mon tableau>.length. Notre boucle
for pourrait donc ressembler à ceci :
Code : Java | char tableauCaractere[] = {'a','b','c','d','e','f','g'};
for(int i = 0; i < tableauCaractere.length; i++)
{
System.out.println("A l'emplacement " + i +" du tableau nous avons = " +tableauCaractere[i]);
}
|
Alors ? Ce n'est pas mieux comme ça ? D'accord, je reformule ma phrase pour ceux qui ont le sens de la contradiction.
C'est mieux comme ça ! Je vais vous donner une preuve que vous ne pourrez pas nier.
Essayez de faire une recherche dans un des tableaux ci-dessus (pas celui contenant des
String, nous verrons ce cas dans le prochain chapitre). En gros : faites une saisie clavier, et regardez si celle-ci existe dans votre tableau... Dur, dur, sans boucle... COMMENT ÇA, C'EST DUR, MÊME AVEC UNE BOUCLE ?
Dans ce cas, je vais vous aider. Gardez la même structure de code permettant de faire plusieurs fois la même action, et 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 :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32 | char tableauCaractere[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
int i = 0, emplacement = 0;
char reponse = ' ',carac = ' ';
Scanner sc = new Scanner(System.in);
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;
System.out.println("Rentrez une lettre en minuscule, SVP ");
carac = sc.nextLine().charAt(0);
while(i < tableauCaractere.length && carac != tableauCaractere[i])//boucle de recherche dans le tableau
i++;
if (i < tableauCaractere.length)//Si i < 7 c'est que la boucle n'a pas dépassé le nombre de cas du tableau ==> il a trouvé
System.out.println(" La lettre " +carac+ " se trouve bien dans le tableau !");
else//sinon
System.out.println(" La lettre " +carac+ " ne se trouve pas dans le tableau !");
}while(i >= tableauCaractere.length);//tant que la lettre de l'utilisateur ne correspond pas à une lettre du tableau
do{
System.out.println("Voulez-vous essayer de nouveau ? (O/N)");
reponse = sc.nextLine().charAt(0);
}while(reponse != 'N' && reponse != 'O');
}while (reponse == 'O');
System.out.println("Au revoir !..");
|
Ce qui nous donne :
Explicitons un peu ce code, et plus particulièrement la recherche
Dans notre
while, il y a deux conditions :
==> la première correspond au compteur. Tant que ce compteur est inférieur ou égal au nombre d'éléments du tableau, on incrémente notre compteur pour regarder la valeur suivante. Nous passons ainsi en revue tout ce qui se trouve dans notre tableau.
MAIS si nous n'avions mis que cette condition, la boucle n'aurait fait que parcourir le tableau, sans voir si le caractère saisi correspond bien à un caractère de notre tableau, d'où la deuxième condition.
==> la deuxième correspond à la comparaison entre le caractère saisi et la recherche dans le tableau. Grâce à ceci, si le caractère saisi se trouve dans le tableau, la boucle prend fin, et donc
i a une valeur inférieure à 7.
À ce stade, notre recherche est terminée. Ensuite, les conditions coulent de source ! Si nous avons trouvé une correspondance entre le caractère saisi et notre tableau,
i aura une valeur inférieure à 7 (je vous rappelle qu'il n'y a que 6 entrées dans notre tableau, puisque nous avons 7 lettres dans celui-ci, et la première entrée a comme indice
0). Dans ce cas, nous affichons un message positif. Et dans le cas contraire, c'est l'instruction du
else qui s'exécutera.
Vous avez dû remarquer la présence d'un i = 0; dans une boucle. Ceci est PRIMORDIAL, car sinon, lorsque vous reviendrez au début de celle-ci, i ne vaudra plus 0, mais la dernière valeur qu'il aura eue, après les différentes incrémentations. Si vous faites une nouvelle recherche, vous commencerez par l'indice contenu dans i ; ce que vous ne voulez pas, puisque vous voulez regarder depuis le début du tableau, donc 0.
Pour bien vous rendre compte de cela, essayez le programme ci-dessus sans cette instruction : vous verrez qu'il n'y a plus de recherche possible, ou même un gros plantage d'Eclipse...
En travaillant avec les tableaux, vous serez confrontés, un jour ou l'autre, au message suivant :
java.lang.ArrayIndexOutOfBoundsException.
Ceci signifie qu'une exception a été levée car vous avez essayé de lire (ou d'écrire dans) une case qui n'a pas été définie dans votre tableau ! Nous verrons les exceptions lorsque nous aborderons la programmation orienté objet.
Exemple
Code : Java | 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
str[11] = "Une exception";
//De même, le code ci-dessous déclenchera la même exception car vous essayez de lire
//une case non définie !
String string = str[24];
|
Faites donc bien attention à cela, car il s'agit de l'une des erreurs commises les plus fréquentes.
Un tableau multi-dimensionnel
Nous allons travailler sur le tableau bi-dimensionnel vu plus haut.
Le principe est vraiment le même que pour un tableau simple. Mais ici, il n'y a que deux compteurs. Voici un code possible pour afficher les données par ligne, c'est-à-dire l'intégralité du
sous-tableau nombres pairs, puis le
sous-tableau nombres impairs :
Avec une boucle while
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13 | int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }, i = 0, j = 0;
while (i < 2)
{
j = 0;
while(j < 5)
{
System.out.print(premiersNombres[i][j]);
j++;
}
System.out.println("");
i++;
}
|
Et voilà le résultat :
Je suppose que vous avez remarqué la drôle de déclaration de variable... Vous avez le droit de faire ainsi. Mais seules les variables ayant les crochets [] après leur nom seront considérées comme des tableaux, les autres resteront des variables toutes simples.
Détaillons un peu ce code
- Dans un premier temps, on initialise les variables.
- On entre ensuite dans la première boucle (qui se fera 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 rentre 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 pour finir le programme.
Ce code affiche donc le contenu des deux tableaux... Encore heureux ! Notez bien que vous devez réinitialiser votre compteur
j avant la boucle où il est utilisé comme argument, sinon celle-ci ne fonctionnera pas. Et cela, pour la même raison que pour un tableau normal.
Le même résultat avec une boucle for
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12 | 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++)
{
System.out.print(premiersNombres[i][j]);
}
System.out.println("");
}
|
En bonus, voici un petit code qui va vous afficher la suite des nombres dans l'ordre, en piochant tantôt dans le tableau pair, tantôt dans le tableau impair :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12 | int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} };
for(int i = 0; i < 5; i++)
{
for(int j = 0; j < 2; j++)
{
System.out.print(premiersNombres[j][i]);
}
}
|
Et voilà :
Vous avez remarqué que la différence entre ces deux codes était seulement l'ordre des conditions dans nos boucles...
Tu ne nous avais pas parlé d'une façon de faire une boucle for ?
Tout à fait, d'ailleurs la voici :
Code : Java | String tab[] = {"toto", "titi", "tutu", "tete", "tata"};
for(String str : tab)
System.out.println(str);
|
Faites bien attention à ne pas confondre les deux syntaxes ! La boucle for, ancienne génération, prend des ; dans ses instructions, alors que la nouvelle version prend un :.
Comme je vous l'avais dit lorsque vous avez vu "
Les boucles", cette syntaxe se rapproche de la boucle
foreach présente dans d'autre langages.
Cette syntaxe signifie qu'à chaque tour de boucle, la valeur courante du tableau est mise dans la variable
str.
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...)
Pour vérifier que les valeurs retournées par la boucle correspondent bien à leurs indices, vous pouvez déclarer un entier (
i, par exemple) initialisé à 0 et incrémenté à la fin de la boucle.
Allez, c'est mon jour de bonté :
Code : Java | String tab[] = {"toto", "titi", "tutu", "tete", "tata"};
int i = 0;
for(String str : tab)
{
System.out.println("La valeur de la nouvelle boucle est : " + str);
System.out.println("La valeur du tableau à l'indice " + i +" est : " + tab[i] + "\n");
i++;
}
|
Ce qui nous donne :
Alors ? Convaincus ?
Vous pouvez voir que cette forme de boucle
for est particulièrement adaptée au parcours de tableau !
D'accord, ça a l'air bien comme méthode, mais pour les tableaux à deux dimensions ?
Même si vous devriez trouver la réponse tout seuls, je vais tout de même vous la donner !
Je vous ai dit que la variable en premier paramètre devait être du même type que la valeur de retour du tableau. Dans le cas qui nous intéresse, que va retourner l'instruction de la boucle
for si on utilise un tableau à deux dimensions ? Un
tableau. Nous devrons donc mettre un tableau, du même type que notre tableau à dimensions, en première instruction de la boucle, et donc faire une deuxième boucle afin de parcourir le résultat obtenu !
Voici un code qui permet d'afficher un tableau à deux dimensions de façon conventionnelle et selon la nouvelle version du JDK 1.5 :
Code : Java 1
2
3
4
5
6
7
8
9
10
11
12
13
14 | String tab[][] = {{"toto", "titi", "tutu", "tete", "tata"}, {"1", "2", "3", "4"}};
int i = 0, j = 0;
for(String sousTab[] : tab)
{
i = 0;
for(String str : sousTab)
{
System.out.println("La valeur de la nouvelle boucle est : " + str);
System.out.println("La valeur du tableau à l'indice [" + j + "][" +i +"] est : " + tab[j][i] + "\n");
i++;
}
j++;
}
|
Ce qui nous donne :
Vous pouvez donc voir que nous récupérons un tableau au parcours de la première boucle et que nous parcourons ce même tableau afin de récupérer les valeurs de celui-ci dans la deuxième. Simple, non ? En tout cas, je préfère nettement cette syntaxe !
Après, c'est à vous de voir...
Vous êtes maintenant parés pour utiliser les tableaux quels qu'ils soient !
Donc, sans plus attendre, je vous propose un petit QCM de derrière les fagots !
Les tableaux
JamesTesYeux
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+