A.9 Les tableaux (1) :
déclaration, affection, taille.

Pour ceux qui n'en n'ont jamais entendu parler, un tableau est une variable particulière, pouvant contenir un ensemble de variables de même type.
Vous comprendrez alors qu'il y a autant de tableaux qu'il y a de variables. Des tableaux de type byte, de type, short, de type int, de type long, float, double, char, String, etc...
Toutes les variables d'un tableaux portent le même nom. La différence se faisant grâce à un indice de valeur numérique.

Trève de commentaires. Allons-y pour les exemples.

Exemple 1

1.     public class Tableaux1
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = new int[4];
6.               tab[0] = 5; tab[1] = 22; tab[2] = 3; tab[3] = 4;
7.               for(int i = 0; i < 4; i++)
8.               {
9.                    System.out.println(tab[i]);
10.              }
11.         }
12.    }

compilez puis exécutez ce programme, il sera affiché :

5
22
3
4
explications :

ligne 5 : déclaration d'un tableau. Vous l'aure compris, les tableaux sont des variables Objets (opérateur new).
int, c'est le type du tableau. tab est le nom du tableau. [] indique que la variable tab est de type tableau. new int[4] signifie que le tableau créé possède 4 éléments.

ligne 6 : On affecte à chaque élément du tableau une valeur de type int. Forcément, puisque le tableau est de type int.
Essayez d'y mettre une valeur qui n'est pas de type int et un message d'erreur sera généré à la compilation. Sauf, évidement si le type affecté peut se convertir implicitement en type int. Exe : byte, short.
Rappel : un tableau est une variable contenant des variables de même type type. Autrement dit, les éléments d'un tableau (ici : tab[0], tab[1], tab[2], tab[3] ) sont des variables de même nom que le tableau (tab) et la différence entre ces éléments (ces variables) c'est le numéro dans les crochets qui suivent le nom de la variable.

Ligne 7 : vous reconnaissez la boucle for. Ici, on demande à exécuter 4 fois l'instruction qui se trouve dans la boucle. A savoir, afficher la valeur d'un élément du tableau, puis de mettre le curseur à la ligne (ln).
Une fois, c'est i = 0. Donc, afficher la valeur de tab[0] qui est 5. Puis aller à la ligne
Deux fois, c'est i = 1. Donc, afficher la valeur de tab[1] qui est 22. Puis aller à la ligne
Trois fois, c'est i = 2. Donc, afficher la valeur de tab[2] qui est 3. Puis aller à la ligne
Quatre fois, c'est i = 3. Donc, afficher la valeur de tab[3] qui est 5. Puis aller à la ligne
Dans le cas où i = 4, la condition booléenne (i<4) n'est plus vérifiée. Donc, le programme sort de la boucle. Comme il n'y a pas d'instructions après la boucle, c'est la fin du programme.

Le type de tableau déclaré dans cet exemple s'appelle tableau unidimensionnel. Il existe des tableaux multidimensionnels. Nous ne les verrons pas dans ce chapitre. A voir au suivant.

Autre façon de déclarer les tableaux unidimensionnels.

Le tableau de l'exemple 1 peut se déclarer de 2 autres façons, comme suit :

1.
Si vous remplacez dans l'exemple 1 ci-dessus, les lignes 5 et 6 par cette seule instruction int [] tab = {5, 22, 3, 4};, il n'y aura aucun message d'erreur et le résultat à l'affichage sera le même. Par cette seule ligne, int est le type, [] signifie tableau, tab est le nom de la variable, dans les accolades, on énumère 4 valeurs, ce qui signifie que le tableau a forcément 4 éléments. Et ces valeurs sont focément dans l'ordre des indices des variables de la variable tab. Donc, forcément, on a : tab[0] = 5; tab[1] = 22; tab[2] = 3; tab[4] = 4;

2.
L'autre façon est comme la première. Avec une toute petite différence. Les crochets sont placés après le nom de la variable et pas avant, comme ceci :
int tab[] = {5, 22, 3, 4}; on peut mettre un espace (ou non) entre tab et les crochets. Coome ceci : int tab [] = {5, 22, 3, 4};. Aucun problème. Dans les livres, autant on met en général un espace entre les crochets et la variable lorsqu'on déclare ainsi : int [] tab = new int[4];, autant on ne met aucun espace entre les crochets et la variable lorsqu'on déclare ainsi : int tab[] = {5, 22, 3, 4};

Sachez que ça n'a aucune espèce d'importance. Présence d'espace ou non, aucun message d'erreur n'est généré, ni à la compilation, ni à l'exécution. L'habitude,
c'est un espace si les crochets se trouvent avant la variables,
et pas d'espace dans le cas contraire.

Exemple 2

1.     public class Tableaux2
2.     {
3.          public static void main (String [] args)
4.          {
5.               int [] tab = new int[4];
6.               tab[0] = 5; tab[1] = 22; tab[2] = 3; tab[3] = 4;
7.               System.out.println("Le nombre de variables du tableau tab est = " + tab.length);
8.               
9.               int [] t = new int[5];     
10.              System.out.println("Le nombre de variables du tableau t est = " + t.length);
11.         }
12.    }

compilez puis exécutez ce programme, il sera affiché :

Le nombre de variables du tableau tab est = 4
Le nombre de variables du tableau t est = 5

ligne 5 : déclaration d'un tableau appelé tab avec un nombre d'éléments possibles égale à 4.
ligne 6 : affectation des variables de tab.
ligne 7 : affichage du nombre d'éléments du tableau tab. Vous l'aurez compris, length est un attribut qui indique le nombre d'éléments d'un tableau.
D'où affichage de 4

Remarque : pour connaitre le nombre de caractères d'un objet de type String, on utilise la méthode length(). exemple : String s = new String("ret");
s.length() donne le nombre de caractères de s.
Alors que length qui donne le nombre d'éléments d'un tableau, n'est pas une méthode. Voilà pourquoi il n'y a pas de parenthèses.

Ligne 9 : déclaration d'un tableau appelé t avec le nombre d'éléments égal à 5.
Ligne 10 : affichage du nombre d'éléments de t.
d'où affichage de 5.

Remarquez : je n'ai pas affecté les variables (éléments) du tableau t. Mais j'ai quand même eu le nombre d'éléments. Donc, pas besoin d'affecter les éléments d'un tableau pour connaitre son nombre d'éléments.

De même, si vous écrivez ceci :

int [] tableau = {5, 11, 7, 5};
System.out.print(tableau.length);

Il y aura aussi l'affichage du nombre d'éléments de tableau = 4

Exemple 3 : 

1.     public class Tableaux3
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] nom = new String[3];
6.               nom[0] = "POL"; nom[1] = "BILL"; nom[2] = "CLINT";
7.               for (int i = 0; i < 3; i++)
8.               {
9.                    System.out.println(nom[i]);
10.              }
11.              
12.              System.out.println("nombre de noms = " + nom.length);
13.         }
14.    }

compilez puis exécutez ce programme, il sera affiché :

POL
BILL
CLINT
nombre de noms = 3

Ligne 5 : déclaration d'un tableau de type String appelé nom, et de longueur 3.
Ligne 6 : affectation des 3 variables du tableau nom
Ligne 9 : affichage ddes valeurs de tous les éléments de nom
Ligne 12 : affichage de la taille du tableau nom.

lexique : En anglais, le mot length signifie : longueur. Donc, la taille.

Exemple 4 : 

1.     public class Tableaux4
2.     {
3.          public static void main (String [] args)
4.          {
5.               String [] nom = new String[6];
6.               nom[0] = "POL"; nom[1] = "BILL"; nom[2] = "CLINT";
7.               nom[3] = "MOL0"; nom[4] = "WILLY"; nom[5] = "KINGSTON";
8.              int i = (int) (Math.random() * 6);
9.              System.out.println("Un nombre entier au hasard  = " + i);
10.             System.out.println("un nom au hasard = " + nom[i]); 
11.              
12.              
13.         }
14.    }

compilez puis exécutez ce programme, il sera affiché :

Un nombre entier au hasard = nbre?
un nom au hasard = nom? nbre? = nbre aléatoire généré par la méthode Math.random.
nom? = nom dont la variable nom[i] est telle que i = nbre?

Ligne 5 : déclaration d'un tableau de type String et de taille 6
Lignes 6 et 7 : affectation des valeurs de type String aux 6 variables du tableau.
Ligne 8 : tirage au sort d'un nombre entier compris entre 0 et 5. Coment ?....
rappel : Math.random() renvoie un nombre de type double compris entre 0 et 1 (0 inclu et 1 exclu).
Donc en multipliant par 6 Math.random(), on aura un un nombre aléatoire compris entre 0 (inclu) et 6 'exclu). Puis je convertis ce nombre en int en mettant devant, int entre parenthèses. Autrement dit, le nombre au hasard sera pris parmi les nombres entiers compris entre 0 et 5 inclus puisque 6 est exclu. Ce seront donc : 0 ou 1 ou 2 ou 3 ou 4 ou 5.
Ligne 8 toujours, je mets cette valeur dans la variable i de type int.

Ligne 9 : affichage du nombre généré au hasard.
Ligne 10 : affichage de la valeur d'un élément du tableau dont l'indice est généré au hasard. Ce qui signifie forcément que le nom affiché est choisi au hasard parmi les 6.
La méthode Math.random(), qui permet de générer un nombre au hasard, permet donc de générer n'importe quelle valeur au hasard.

Exemple 5 

1.     public class Tableaux5
2.     {
3.          public static void main (String [] args )
4.          {
5.               int  [] t = new int[3];
6.               System.out.println("t[0] = " + t[0]);
7.               System.out.println("t[1] = " + t[1]);
8.               System.out.println("t[2] = " + t[2]);
9.          }
10.    }

compilez puis exécutez, il sera affiché :

t[0] = 0
t[0] = 0
t[0] = 0

Lorsque vous créez un tableau comme sur la ligne 5, sans donner de valeur aux éléments du tableau, ces derniers sont automatiquement initialisés avec la valeur nulle.
0 pour les tableaux de type byte, short, int et long. 0.0 pour les nombres décimaux float et double. zéro caractères pour les tableaux de type String.
Pour le type char, la valeur est le caractère espace. Pour le type boolean, la valeur est "false".

Exemple 6 

1.     public class Tableaux6
2.     {
3.          public static void main (String [] args )
4.          {
5.               int  [] t1, t2, t3 = new int[3];
6.               System.out.println("taille de t1 = " + t1.length);
7.               System.out.println("taille de t2 = " + t2.length);
8.               System.out.println("taille de t3 = " + t3.length);
9.          }
10.    }

compilez ce programme. Et un message d'erreur s'affichera. 2 messages

variable t1 might not have been initialized System.out.println("taille de t1 = " + t1.length); ^ variable t2 might not have been initialized System.out.println("taille de t1 = " + t2.length); ^

Cela veut dire que les variables t1 et t2 n'ont pas été initialisées. Java ne peut donc pas afficher la taille des tableaux t1 et t2. Pourquoi ?
Commençons par le début.

Ligne 5 : Tout comme on peut créer des variables de même type de base, par exemple int : int a, b, c; De même, ont peut créer des tableaux de même type :
En ligne 5, on crée 3 tableaux t1, t2 et t3 de type int et de taille = 3.
Mais ici, java refuse d'initialiser les 2 premiers tableaux. Du coup, il ne peut pas donner une taille à ces tableaux. D'où les 2 messages d'erreur.
Naturellement, la question que vous vous poez est de savoir pourquoi initialiser le dernier tableau seulement ? ... un peu de recherche sur vos cours ou sur le Net vous permettra de trouver. Un bon informaticien doit faire ses recherches personnelles.
A partir de maintenant, je vous inviterais à faire des recherches personnelles pour certains notions.

Exemple 7 

1.     public class Tableaux7
2.     {
3.          public static void main (String [] args )
4.          {
5.               int  [] t1, t2, t3 = new int[3];
6.               System.out.println("taille de t3 = " + t3.length);
7.               System.out.println("valeur de t3[0] = " + t3[0]);
8.               System.out.println("valeur de t3[1] = " + t3[1]);
9.               System.out.println("valeur de t3[2] = " + t3[2]);
10.         }
11.    }

compilez puis exécutez ce programme, il sera affiché :

taille de t3 = 3
valeur de t3[0] = 0
valeur de t3[1] = 0
valeur de t3[2] = 0

Ce programme prouve bien que le tableau t3 a été initialisé, puisque sa taille est donnée (ligne 6) et la valeur zéro est donnée à ses trois éléments (lignes 7, 8 et 9).

Une dernière chose sur cet exemple : La déclaration ligne 5 de plusieurs tableaux en une fois se fait avec les crochets ([]) avant les noms de tous les tableaux déclarés. Si vous changez de position, les variables changent de type. Voyons quelques exemples de déclarations

1.     int t1, t2, t3 [];
2.     int t1, t2, [] t3;
3.     int t1, t2[] , t3;

ligne 1 : seul t3 est un tableau. t1 et t2 sont de simples variables de type int
ligne 2 : message d'erreur à la compilation. lorsque vous déclarez plusieurs d'un type (ici int par exemple) dont certains sont des tableaux, vous avez l'obligation de mettre les crochets avant le nom de la variable. Ce qui est fait en ligne 3. En ligne 3 donc, seul t2 est un tableau. t1 et t3 sont de simples variables de type int.

D'où le conseil très très recommandé suivant : si vous voulez déclarer des variables de type de base et des tableaux de même type, surtout faites le sur 2 lignes.

1.     int a, b, c;
2.     int [] t1, t2, t3;

a, b et c sont de simples variables de type int, alors que t1, t2 et t3 sont des variables tableaux de type int. Voilà ! C'est clair, net et précis. Aucune ambiguité.

Exemple 8 

1.     public class Tableaux8
2.     {
3.          public static void main (String [] args )
4.          {
5.               int  [] t = new int[3];
6.               t[3] = 5;
7.               System.out.println("affichage de la valeur de t[3] = " + t[3]);
8.         }
9.     }

compilation bonne. Mais à l'exécution, un message d'erreur :

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException : 3

Une exception est une erreur spécifique. Ici, l'erreur est de type dépassement des limites du tableau.
out of bounf = hors des limites
array = tableau

Ici, c'est l'erreur des débutants. Le tableau a 3 éléments (ligne 5), alors, on crois que l'élément d'indice 3 existe. Erreur. Souvenez-vous de ce que j'ai dit au début de ce chapitre. Le premier élément est toujours d'indice 0.
Voilà pourquoi, lorsqu'on parcourt les éléments du tableau avec la boucle for, il faut toujours commencer par l'indicie 0 : for (int i = 0....)
Sauf si évidement, on veut parcourir le tableau à partir d'un élément qui n'est pas le premier.

Exemple 9 :


1.     public class Tableaux9
2.     {
3.          public static void main (String [] args )
4.          {
5.               int  [] tab;
6.               tab[0] = 1;
7.          }
8.     }

à la compilation, message d'erreur

variable tab might not have been initialized
tab[0] = 1; ^ La variable tab pourrait n'avoir pas été initialisé.

Pour les variables de type de base, exemple : int a; a = 1; ce n'est pas un problème. Pour les tableaux, l'initialisation doit se faire à la création du tableau.
int tab = new int[2]; par exemple.

Un tableau doit être initialisé. Pour ce faire, on doit connaitre la taille du tableau avant son utilisation. Même lorsque vous créez un tableau dont le nombre d'éléments ne sera connu que plus tard dans le programme, il faut trouver une astuce pour ne pas déclencher de message d'erreur.
Par exemple, le nombre d'éléments sera saisi par l'utilisateur avant l'utilisation du tableau. Ce cas sera traité au chapitre suivant.

Les tableaux sont une structure donnée très puissante. Au chapitre suivant, nous aurons l'occasion de nous en rendre compte.

Pour la suite de ce chapitre, nous allons aborder les tableaux multidimensionnels.
Un tableau multidimensionnel est un tableau de tableaux, de tableaux, etc..... : C'est un tableau dont les éléments sont eux-mêmes des tableaux, qui à leur tour ont pour éléments des tableaux etc....

Pour vous débutants, je vais seulement aborder des tableaux bi-dimensionnels. Autrement dit, des tableaux de tableaux. Car, manipuler des tableaux bi-dimensionnels peut s'avérer pénible. Sauf pour ceux qui maitrisent les dimensions précédentes. D'abord maitriser une dimension, puis 2, puis 3, ainsi de suite.

Exemple 10 :

1.     public class Tableaux10
2.     {
3.          public static void main (String [] args )
4.          {
5.               //Création d'un tableau à 2 dimensions appelé mat
6.               int [][] mat = new int[2][3];
7.               
8.               // affichage de la taille de mat et celle de ses 2 éléments
9.               System.out.println("taille du tableau mat = " + mat.length + "\n");
10.               Sytem.out.println("taille du tableau mat[0] = " + mat[0].length);
11.               Sytem.out.println("taille du tableau mat[1] = " + mat[1].length + "\n");
12.              
13.             // afficher les valeurs des éléments du premier tableau de mat
14.             Sytem.out.println("Valeur de mat[0][0] = " + mat[0][0]);
15.             Sytem.out.println("Valeur de mat[0][1] = " + mat[0][1]);
16.             Sytem.out.println("Valeur de mat[0][2] = " + mat[0][2] + "\n");
17.
18.             // afficher les valeurs des éléments du deuxième tableau de mat
19.             Sytem.out.println("Valeur de mat[1][0] = " + mat[1][0]);
20.             Sytem.out.println("Valeur de mat[1][1] = " + mat[1][1]);
21.             Sytem.out.println("Valeur de mat[1][2] = " + mat[1][2]);
22.         }
23.    }

Compilation, puis exécution, il sera affiché :

taille du tableau mat = 2

taille du tableau mat[0] = 3
taille du tableau mat[0] = 3

Valeur de mat[0][0] = 0
Valeur de mat[0][1] = 0
Valeur de mat[0][2] = 0

Valeur de mat[1][0] = 0
Valeur de mat[1][1] = 0
Valeur de mat[1][2] = 0

Explications :

D'abord, "\n" permet d'afficher une ligne vide.

Ligne 6 : je crée un tableau à 2 dimensions de type int. int [][] mat veut dire que la tableau appelé mat est à 2 dimensions. Ensuite, new int[2][3] veut dire que la variable tableau mat possède 2 éléments et chacun de ces 2 éléments (qui sont forcément des tableaux eux aussi) ont chacun, 3 éléments.

Ligne 9 : affichage du tableau mat : on voit bien que le nombre est égal à 2

Ligne 10 : affichage de la taille du premier élément de mat qui est mat[0] : il s'est affiché le nombre 3
Ligne 11 : affichage de la taille du deuxième élément de mat qui est mat[1] : il s'est affiché le nombre 3

Ligne 14 : affichage de la valeur du premier élément de mat[0] qui est mat[0][0] : égal à 0
Ligne 15 : affichage de la valeur du deuxième élément de mat[0] qui est mat[0][1] : égal à 0
Ligne 16 : affichage de la valeur du troisième élément de mat[0] qui est mat[0][2] : égal à 0

Ligne 19 : affichage de la valeur du premier élément de mat[1] qui est mat[1][0] : égal à 0
Ligne 20 : affichage de la valeur du deuxième élément de mat[1] qui est mat[1][1] : égal à 0
Ligne 21 : affichage de la valeur du troisième élément de mat[1] qui est mat[1][2] : égal à 0

Comme je vous l'avais dit au début de ce chapitre, exemple 5, lorsqu'on crée un tableau, les valeurs données aux éléments sont nulles. La question que vous pouvez vous poser est de savoir quelle est la valeur des deux éléments de mat. A savoir mat[0] et mat[1]
Je vous rappelle que ces deux éléments sont des tableaux eux-aussi. Donc, pas de valeur attribuée. Mais si vous essayez d'afficher leur valeur en écrivant ceci :

System.out.println("Valeur de mat[0] = " + mat[0]);

Vous aurez un affichage sans message d'erreur. La valeur sera un ensemble de chiffre avec d'autres caractères comme par exemple @. Tout dépend du système d'exploitation que vous utilisez et aussi de votre ordinateur. Cette valeur est en fait une référence. Une sorte d'adresse mémoire. Nous auront l'occasion d'en parler en POO (programmation otrientée objet).

En POO, les objets ont non seulement une valeur (éventuellement), mais surtout et forcément, une référence.

La ligne 6 de l'exemple ci-dessus int [][] mat = new int[2][3]; pourrait vous faire croire que dans un tableau de tableaux, tous les éléments du tableau ont la même taille. Par exemple, que mat[0] et mat[1] auront forcément la même taille. Pas du tout. J'aurais pu créer mat en faisant en sorte que ces 2 éléments aient une taille différente. Comment ?
Exemple suivant :

Exemple 11 :

1.     public class Tableaux11
2.     {
3.          public static void main (String [] args )
4.          {
5.               
6.               int [][] mat = new int[2][];
7.               mat[0] = new int[3];
8.               mat[1] = new int[4];
9.               
10.              System.out.println("taille de mat[0] = " + mat[0].length);
11.              System.out.println("taille de mat[1] = " + mat[1].length + "\n");
12.              
13.              int [][] matrice = { {1, 2 }, {2, 7, 1} };
14.              System.out.println("taille de matrice[0] = " + matrice[0].length);            
15.              System.out.println("taille de matrice[0] = " + matrice[1].length);
16.             
17.         }
18.    }

compilez puis exécutez, il sera affiché :

taille de mat[0] = 3
taille de mat[1] = 4

taille de matrice[0] = 2
taille de matrice[1] = 3

Ligne 6 : je crée un tableau à 2 dimensions appelé mat. mat est donc un tableau de tableaux. Le chiffre 2 dans la première paire de crochets de new int[2][] indique que mat a 2 éléments.
Mais la deuxième paire de crochets est vide. Donc les 2 éléments de mat (mat[0] et mat[1] ) n'ont pas de dimension à ce stade.
Ligne 7 : on indique que mat[0] a une taille de 3 éléments
Ligne 8 : on indique que mat[1] a une taille de 4 éléments
D'où l'affichage dde leurs tailles respectives.

REMARQUE : si vous tentez de remplacer les lignes 7 et 8 par :

int mat[0] = new int[3];
int mat[1] = new int[4];

messages d'erreur à la compilation. Pas besoin de retyper mat[0] et mat[1]. Puisque la ligne 6 montre qu'ils sont de type int.

Souvenez-vous, exemple 1, dans les explications, je vous disais qu'on pouvait définir un tableau (unidimensionnel) ainsi : int tab [] = {5, 22, 3, 4};

On peut faire de même pour les multidimensionnels comme sur la ligne 13 de l'exemple ci-dessus. On met les valeurs de chaque tableau entre les accolades. Puis on sépare les accolades par une virgule. Et enfin, on englobe le tout dans une autre paire d'accolades.

Vous voyez bien que l'affichage de la taille de chaque élément de matrice correspond bien au nombre d'éléments respectifs.

Donc, étant donné un tableau multidimentsionnel quelconque m, chque élément de m est un tableau qui peut posséder sa propre taille ou tous peuvent avoir la même taille.
Tout dépend de quelle façon on déclare du tableau.

Un peu de vocable : les tableaux à 2 dimensions sont appelés des matrices.

Voilà ! Nous sommes à la fin du chapitre. Mais au prochain, nous allons aborder un grand nombre d'exercices sur les tableaux. Ce qui vous permettra d'en savoir plus sur ces variables .

← (précédent) A.8 Les structures de contrôle (2) : if - if...else - else if - switch

A.10 Les tableaux (2) : exercices corrigés tableaux uni et bi dimensionnels →

Accueil ↔ S O M M A I R E

A.9 Les tableaux (1) : déclaration, affection, taille.