Les tableaux

• TP : conversion Celsius - Fahrenheit
• Sommaire
• Les méthodes de classe

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

Vous vous doutez (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 en effet pouvoir lui affecter plusieurs valeurs ordonnées séquentiellement que nous pourrons appeler au moyen d'un indice (ou d'un compteur, si vous préférez). Il nous suffira d'introduire l'emplacement du contenu désiré dans notre variable tableau pour la sortir, travailler avec, l'afficher…

Assez bavardé : mettons-nous joyeusement au travail !

• Tableau à une dimension
• Les tableaux multidimensionnels
• Utiliser et rechercher dans un tableau

Tableau à une dimension

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 ! C'est très logique : 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 :

1

<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 :

1
2
3
4

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 :

1
2
3

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 :

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 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 :

Maintenant, je vais vous proposer de vous amuser un peu avec les tableaux…

Utiliser et rechercher dans un tableau

Avant d'attaquer, je dois vous dire quelque chose de primordial : un tableau débute toujours à l'indice 0 ! Je m'explique : prenons l'exemple du tableau de caractères contenant les lettres de l'alphabet dans l'ordre qui a été donné plus haut. Si vous voulez afficher la lettre « a » à l'écran, vous devrez taper cette ligne de code :

1

System.out.println(tableauCaractere[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 2^e élément, le 2 correspond au 3^e élément et le 3 correspond au 4^e élément.

Ce que je vous propose, c'est tout simplement d'afficher un des tableaux présentés ci-dessus dans son intégralité. Sachez qu'il existe une instruction qui retourne la taille d'un tableau : grâce à elle, nous pourrons arrêter notre boucle (car oui, nous allons utiliser une boucle). Il s'agit de l'instruction <mon tableau>.length. Notre boucle for pourrait donc ressembler à ceci :

1
2
3
4
5
6

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

for(int i = 0; i < tableauCaractere.length; i++)
{
  System.out.println("À l'emplacement " + i +" du tableau nous avons = " + tableauCaractere[i]);
}

Cela affichera :

1
2
3
4
5
6
7

À 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 :

 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

char tableauCaractere[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
int i = 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);
    //Boucle de recherche dans le tableau
    while(i < tableauCaractere.length && 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 < tableauCaractere.length)
      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 à nouveau ? (O/N)");
    reponse = sc.nextLine().charAt(0);
  }while(reponse != 'N' && reponse != 'O');      
}while (reponse == 'O');

System.out.println("Au revoir !");

Le résultat de ce code se trouve à la figure suivante.

Explications sur la recherche

Dans notre while, il y a deux conditions.

La première correspond au compteur : tant que celui-ci est inférieur ou égal au nombre d'éléments du tableau, on l'incrémente pour regarder la valeur suivante. Nous passons ainsi en revue tout ce qui se trouve dans notre tableau. 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 à elle, 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. Après cela, les conditions coulent de source ! Si nous avons trouvé une correspondance entre le caractère saisi et notre tableau, i prendra une valeur inférieure à 7 (vu qu'il y a 7 éléments dans notre tableau, l'indice maximum étant 7-1, soit 6). Dans ce cas, nous affichons un message confirmant la présence de l’élément recherché. Dans le cas contraire, c'est l'instruction du else qui s'exécutera.

En travaillant avec les tableaux, vous serez confrontés, un jour ou l'autre, au message suivant :

1

java.lang.ArrayIndexOutOfBoundsException

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

1
2
3
4
5

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

 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++;
}

Le résultat se trouve à la figure suivante.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

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("");     
}

Je vous avais parlé d'une nouvelle syntaxe pour cette boucle, la voici :

1
2
3
4

String tab[] = {"toto", "titi", "tutu", "tete", "tata"};

for(String str : tab)
  System.out.println(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 !

Voici un code qui permet d'afficher un tableau à deux dimensions de façon conventionnelle et selon la version du JDK 1.5 (cette syntaxe ne fonctionnera pas sur les versions antérieures au JDK 1.5) :

 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]);
    i++;
  }
  j++;
}

Je vous laisse le soin d'essayer ce code. Vous pourrez voir que nous récupérons un tableau au cours de la première boucle et 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…

• 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.
• Vous pouvez utiliser la syntaxe du JDK 1.5 de la boucle for pour parcourir vos tableaux : for(String str : monTableauDeString).

• TP : conversion Celsius - Fahrenheit
• Sommaire
• Les méthodes de classe