Les tableaux

Les tableaux

Comme dans tout langage de programmation qui se respecte, Java travaille aussi avec des tableaux.
Vous verrez que ceux-ci s'avèrent bien pratiques...

Mais un tableau... Qu'est-ce que c'est, au juste ?

Très bonne question. Vous vous doutez bien (je suppose) que les tableaux dont nous parlons n'ont pas grand-chose à voir avec ceux que vous connaissez ! En programmation, un tableau n'est rien d'autre qu'une variable un peu particulière... nous allons pouvoir lui affecter plusieurs valeurs, rangées de façon séquentielle, que nous pourrons appeler grâce à un indice, ou un compteur, si vous préférez. Il nous suffira de donner l'emplacement du contenu dans notre variable tableau pour la sortir, travailler avec ou encore l'afficher.

Assez bavardé : mettons-nous joyeusement au travail !

Sommaire du chapitre :

Déclarer et initialiser un tableau
Les tableaux multi-dimensionnels
Utiliser et rechercher dans un tableau !

Déclarer et initialiser un tableau

Je viens de vous expliquer, grosso-modo, ce qu'est un tableau en programmation. Si maintenant, je vous disais qu'il y a autant de types de tableaux que de types de variables ? Je crois voir quelques gouttes de sueur perler sur vos fronts...
Pas de panique ! Je dirais même que c'est très logique. Comme nous l'avons vu lors du 3° chapitre, une variable d'un type donné ne peut contenir que des éléments de ce type.
Exemple : une variable de type int ne peut pas recevoir une chaîne de caractères.

Il en est de même pour les tableaux... un tableau d'entiers ne pourra pas recevoir des chaînes de caractères, et vice versa. Voyons tout de suite comment se déclare un tableau :

<type du tableau> <nom du tableau> [] = { <contenu du tableau>};

La déclaration ressemble beaucoup à celle d'un argument de classe quelconque, si ce n'est la présence des crochets [] après le nom de notre tableau, et les accolades {} encadrant l'initialisation de celui-ci.
Dans la pratique, ça nous donnerait quelque chose comme ceci :

Pour un tableau d'entiers

Code : Java

1	int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};

Pour un tableau de double

Code : Java

1	double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};

Pour un tableau de caractères

Code : Java

1	char tableauCaractere[] = {'a','b','c','d','e','f','g'};

Pour un tableau de chaînes de caractères

Code : Java

1	String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};

Vous remarquez bien que la déclaration et l'initialisation d'un tableau se font comme pour une variable normale (si on peut dire qu'une variable est normale...).
Nous utilisons des ' ' pour initialiser un tableau de caractères, des " " pour initialiser un tableau de String, etc.

Vous pouvez aussi déclarer un tableau vide !

Attention, votre tableau sera vide mais, il doit avoir un nombre de cases défini !

Par exemple, si vous voulez un tableau vide de six entiers :
Code : Java

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 voir une belle variante de ceci : les tableaux multi-dimensionnels.

Les tableaux multi-dimensionnels

Ici, les choses se compliquent un peu. Car un tableau multi-dimensionnel n'est rien d'autre qu'un tableau ayant comme contenu au minimum 2 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. Comme tout ce que je vous apprends en général !
Ben oui... Si j'y arrive, vous aussi vous pouvez y arriver ! Alors, on se lance ? GO !

Je ne vais pas vous faire de grand laïus sur ce type de tableau, puisque je pense sincèrement qu'un exemple vous 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 :
Code : Java

1	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 n'est rien d'autre que plusieurs tableaux en un. 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 colonne paire.
Et premiersNombres[1][0] correspondra au premier élément de la colonne impaire.

Allez ! Un petit schéma en guise de synthèse :

Surtout, n'oubliez pas de séparer vos différents tableaux par une ',' et de bien mettre le tout entre accolades. Sinon, c'est le plantage assuré, et de toutes façons, Eclipse n'en voudra pas.

Je pense que vous savez tout ce qu'il y a à savoir sur les tableaux. Maintenant, je vous propose de faire un peu mumuse avec...

Utiliser et rechercher dans un tableau !

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

1	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

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

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

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

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);

Voici le résultat :

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

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 !

// // 1 comments //

1 comments to "Les tableaux"

November 15, 2013 at 4:42 PM
Anonymous says:

c est bizzare qu ya pas de commentaire bravo j ai bien aimer votre maniéré d expliquer ça me rentre dans la téte en fait j ai laisser mon cours cnam et je commence a me preparer a mon exam via vos cours merci chapeau

java du zéro

Les tableaux

Déclarer et initialiser un tableau

Pour un tableau d'entiers

Pour un tableau de double

Pour un tableau de caractères

Pour un tableau de chaînes de caractères

Les tableaux multi-dimensionnels

Utiliser et rechercher dans un tableau !

Voici un parcours de tableau avec une boucle while

Même résultat que précédemment, mais avec une boucle for (à utiliser de préférence)

Explicitons un peu ce code, et plus particulièrement la recherche

Exemple

Un tableau multi-dimensionnel

Avec une boucle while

Détaillons un peu ce code

Le même résultat avec une boucle for

1 comments to "Les tableaux"

Post a Comment

About This Blog

Blog Archive