Imaginez un besoin de manipuler un ensemble de 1 000 variables de même type. Vous rendez-vous compte du travail fastidieux consistant à déclarer toutes ces variables ? La solution, les tableaux bien-sûr !

EXEMPLE 1 :  


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

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

position 0 = 0
position 1 = 0
position 2 = 0
position 3 = 0


Explications :

Les variables de type tableau sont des variables de type Objet. Donc, forcément, on les déclare avec le mot clé new. Nous y reviendrons en détail en POO (programmation orientée objet).
Ligne 6, on déclare une variable appelée tab de type tableau (parce que [] précède le nom de la variable) dont les valeurs sont de type int. La seule déclaration serait ceci : int [] tab; Mais il y a affectation non pas d' une valeur à la variable. Mais plutôt d' un nombre de valeurs que doit contenir cette variable. Ici, ce nombre est égal à 4.

Autre exemple : String [] nom = new String [5]; => Déclaration d' une variable de type tableau dont les valeurs, au nombre de 5 sont de type String.

Autre exemple : double [] notes = new double [8]; => Déclaration d' une variable de type tableau dont les valeurs, au nombre de 8 sont de type double.

Vous l' aurez compris. Une valeur de type tableau contient non pas une seule valeur. Mais possibilité de plusieurs valeurs de même type.

Revenons à l' exemple 1 :
La boucle dit que de la position zéro (celui du premier élément du tableau) à la position correspondant à la taille du tableau moins 1 (i < tab.length veut dire que la dernière valeur de i est la taille du tableau moins 1 puisque strictement inférieur), afficher le mot position suivi de la valeur de i et suivi de la valeur du tableau en position i.

Un peu compliqué ? Peut-être ! Je reprends. Dans la mémoire, les éléments d' un tableau sont contigus. L' élément en première position (0) suivi de l' élément en position 1, lui même suivi de l' élément en position 2, ainsi de suite jusqu' au dernier élément. Ici, il y a 4 éléments. Ces éléments sont en position 0, 1, 2 et 3. Ces éléments sont appelés : tab[0], tab[1], tab[2] et tab[3]. On commence toujours par zéro. Il peut arriver, dans la résolution d' un problème de tableaux que vous n' ayez pas besoin de mentionner l' élément en position 0. Mais sachez qu' il existe forcément.
Revenons à la boucle. Elle parcours les positions allant de zéro à une position inférieur à la taille du tableau. La taille est 4. Donc, à la position 3. Donc, la boucle parcours toutes les positions du tableau. Pour chaque position, on affiche la valeur de l' élément en cette position.

La question évidente que vous allez certainement vous poser est de savoir pourquoi chacun des éléments du tableau a une valeur zéro alors même qu' on n' a pas pris le soin d 'initialiser (donner une valeur initiale) à chacun de ces éléments. ça c' est une spécificité des variables tableau (et de manière générale, des variables de type Objet). Quand on créé une variable tableau avec l' opérateur new, forcément, tous ces éléments sont initialisés :
A zéro s' ils sont de type byte, short, int, et long.
A 0.0 s' ils sont de type float ou double. A false s' ils sont de type boolean.
Au caractère espace s' ils sont de type char
Au mot clé null s' ils sont de type String ou de type Objet en général. Lorsque c' est un objet String, il possèdera zéro caractères : ""; Pour les objets en général, on verra plus tard.

Sachez qu' un tableau peut posséder un seul élément. Mais dans ce cas évidement, le principe de tableau ne sert plus à rien. Vaut mieux déclarer en variable qui ne soit pas tableau. Cela dit, dans les tableaux multi-dimmensionnels, un seul élément dans un tableau n' est pas forcément anormal. Nous verrons les tableaux multidimensionnnels vers la fin de ce paragraphe.

En revanche, untableau ne peut pas posséder zéro éléments. Mais si vous déclarez un tableau avec zéro éléments (ex : int [] tab = new int [0];), il n' y aura pas d' erreur à la compilation. Mais si vous essayez d' accéder à l' un des éléments du tableau, il y aura erreur plutôt à l' exécution. Dans la manipulation des tableaux, c' est souvent que vous aurez des erreurs à l' exécution plutôt qu' à la compilation. Pas tout le temps. Quelques fois.

De même que l' instruction int a = 5; correspond à deux instructions : int a; (déclaration de la variable a de type int ) et a = 5; (affectation de la valeur 5 à la variable a
De même l' instruction int [] tab = new int [4]; correspond à deux instructions : int [] tab; (déclaration de la variable tableau tab de type int et tab = new int [4]; (affectation de 4 éléments de type int et initialisation automatique de ces 4 éléments avec la valeur zéro.

EXEMPLE 2 :  


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

A la compilation, erreur s' affiche : Array dimension missing

Ce qui veut dire que vous avez oublié de mentionner le nombre d' éléments du tableau.

EXEMPLE 3 :  


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

A la compilation, aucune erreur. Normal. Ici, il y a simple déclaration du tableau. Tout comme int a; ne peut pas déclencher une erreur. Mais...

EXEMPLE 4 :  


1.     public class Tableaux4
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [] tab;
7.               System.out.print("premier element : " + tab[0]);
8.          }
9.     }

A la compilation, déclenchement d' une erreur. On déclare la variable tableau sans lui affecter le nombre d' éléments. Et on veut afficher la valeur du premier élément. forcément, pas normal. L' erreur que vous lirez veut dire que la variable tab n' a pas été initialisée. variable tab might not have been initialized.

EXEMPLE 5 :  


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

Si vous compilez ce programme, aucun message d' erreur. Mais à l' exécution, un message d' erreur s' affiche :
Exception in thread "main" java.lang.ArrayIndexOutOfBoundException : 5

Ce qui veut dire qu' une erreur s' est produite dans la fonction main. Cette erreur consiste en une tentative d' accéder à un élément hors limite (out of bounds). Le tableau (Array) contient 5 éléments (ligne 6). Ces éléments sont forcément en positions 0, 1, 2, 3 et 4. Or la ligne 8 contient l' élément tab[5], donc en position 6. Une position qui est hors des limites du tableau.

EXEMPLE 6 :  


1.     public class Tableaux6
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [] tab = {2, 5, 1, 0, 35 };
7.               System.out.println("taille du tableau = " + tab.length);
8.               for(int i = 0; i < tab.length; i++)
9.               {
10.                    System.out.println("element en position " + i + " = " + tab[i]);
11.              }
12.         }
13.    }   

Compilez puis exécuter, il sera affiché :

taille du tableau = 5
element en position 0 = 2
element en position 1 = 5
element en position 2 = 1
element en position 3 = 0
element en position 4 = 35

Ligne 6 : autre façon de déclarer et d' initialiser les éléments du tableau. int [] tab = déclaration d' une variable tableau appelée tab. Et en même temps, affectation des éléments du tableau. Le nombre de valeurs dans les accolades est forcément la taille du tableau. Logique. Le tableau possède donc 5 éléments. D' où l' affichage de taille du tableau. Puis la boucle que je n' ai plus besoin de vous expliquer permet d' afficher la valeur de chaque élément du tableau.

ATTENTION !!! Dans la classe String, on connaît le nombre de caractères d' une chaine grâce à la méthode length(). Le nombre de caractères de la variable chaine est alors fournie par l' expression : chaine.length();
Dans les tableaux, la taille est fournit par la variable tab.length; Remarquez, ici pas de parenthèses.

EXEMPLE 7 :  


1.     public class Tableaux7
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [] tab = {2, 5, 1, 0, 35 };
7.               int [] tablo = tab;
8.               for(int i = 0; i < tablo.length; i++)
9.               {
10.                    System.out.println("element en position " + i + " = " + tablo[i]);
11.              }
12.         }
13.    }   

compilez puis exécutez. Il sera affiché :

element en position 0 = 2
element en position 1 = 5
element en position 2 = 1
element en position 3 = 0
element en position 4 = 35

Qu' ext-ce que ça veut dire ?... Ligne 6 : on déclare une variable tableau tab de type int. Puis affectation des valeurs aux 5 éléments de ce tableau. Puis ligne 7 : déclaration d' un deuxième tableau appelé tablo. Puis on lui affecte le contenu de la première variable tableau. Du coup, tablo contient tout ce que contient tab. C' est à dire, 5 éléments dont les valeurs sont 2, 5, 1, 0 et 35. D' où l' affichage.

La ligne 7 peut aussi s' écrire en deux instructions : int [] tablo; et tablo = tab;

EXEMPLE 8 :  


1.     public class Tableaux8
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               System.out.print("Combien d' elements pour votre tableau : ");
7.               int n = Lire.entierInt();
8.               int [] tab = new int [n];
9.               for(int i = 0; i < n; i++)
10.               {
11.                    System.out.println("position " + i + " = " + tab[i]);
12.              }
13.         }
14.    }   

compilez puis exécutez. Il sera affiché :

Combien d' elemnts pour votre tableau :_
uis vous entrez un nombre et vous appuyez sur entrez. Aussitôt, il s' affiche le même résultat qu' à l' exemple 1. Evidement, à une différence près. Le nombre de lignes étant exactement l' entier positif non nul que vous auriez saisi au clavier.

Il peut vour arriver de vouloir manipuler une variable tableau, tout en sachant que le nombre d' éléments sera variable d' une exécution à l' autre. La solution consiste donc à saisir la taille du tableau à l' écran. Parce que la taille d' un tableau reste fixe au cours de la même exécution. Les tableaux dont la taille peut varier au cours de la même exécution s' appellent des collections. Nous les étudierons plus tard.

EXEMPLE 9 :  


1.     public class Tableaux9
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               byte [] tab = new byte [3];
7.               tab[2] = 354;
8.               
9.          }
10.    }   

Compilez ce programme et un message d' erreur s' affichera :
possible loss of precision
found int
required byte
tablo[2] = 354;

Lorsque vous déclarez un tableau dont les éléments ont des valeurs d' un certain type, Chacun de ces éléments se comporte exactement comme n' importe quelle variable de ce type. Ici, on déclare une variable tableau dont les éléments sont de type byte (ligne 6). Et on essaye de mettre dans un de ses éléments, une valeur de type int (ligne 7). D' où message d' erreur.
Par contre, dans la situation inverse, il y aurait eu conversion implicite, comme dans tout passage d' une variable de type byte au type int.

Puisque chaque élément d' un tableau d' un certain type, se comporte comme toute variable de ce type, on peut donc l' affecter comme toute variable de ce type. En l' occurence, on peut l' affecter par une expression. Par exemple : tab[1] = n + 1; n étant une variable préalablement déclarée et initialisée.

A ce stade, c' est peut-être devenu inutile, mais je le dis quand même : On peut manipuler chaque élément d' un tableau sans que cela ait le moindre impact sur les autres. Normal, les éléments d' un tableau sont des variables indépendantes l' une des autres. Le seul point commun, c' est qu' elles ont le même nom (celui du tableau) mais indice différent, qu' elles ont des positions contigus (une juste à côté de l' autre) en mémoire.

Lorsque vous voulez manipulez plusieurs variables d' un même type, vous avez le choix de déclarer chaque variable ou d' utiliser une variable tableau. Il vous apparaît évident (je l' espère) que les tableaux offrent plus de facilité. Si ce n' est pas encore le cas, les exercices sur les tableaux (prochain paragraphe 1.12) vous convaincont définitivement.

Vous voulez manipulez les notes en mathématiques de tous les élèves de terminale ? ... les tableaux. Vous ferez par exemple la déclaration suivante : double [] notesMaths = new double [25];
Vous pourrez ainsi connaître la moyenne des notes, le maximum ou le minimum. (voir exos sur les tableaux

Vous vouliez manipulez les notes de toutes les matières d' un même élève ? ... Les tableaux aussi. double [] notesDupont = new double[9];

Supposez maintenant que vous vouliez manipuler toutes les notes de tous les élèves d' une classe. Les tableaux encore. Mais cette fois, vous avez le choix de manipuler 25 tableaux (si la classe contient 25 élèves) de notes, ou alors manipuler un tableau bi-dimensionnel. Cette deuxième solution a le même avantage qu' offre un tableau de variables face aux déclarations de toutes les variables. Concrètement, vous aurez ceci :

int [][] eleves = new int [25][9];

De même, on peut avoir affaire à des tableaux tridimensionnels. Ex : int [][][] tab = new int [25][9][2];

Cela peut devenir incroyablement complexe avec les tableaux multi-dimensionnels. Voyons plutôt quelques exemples simples.

EXEMPLE 10 :  


1.     public class Tableaux10
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [][] tab = new int [3][5];
7.               
8.               System.out.println("longueur du tableau tab = " + tab.length);
9.               System.out.println("longueur du premier tableau de tab tab[0] = " + tab[0].length);
10.              System.out.println("longueur du premier tableau de tab tab[1] = " + tab[1].length);
11.              System.out.println("longueur du premier tableau de tab tab[2] = " + tab[2].length);
12.         }
13.    }

compilez puis exécutez. il sera affiché :

longueur du tableau tab = 3
longueur du premier tableau de tab tab[0] = 5
longueur du premier tableau de tab tab[1] = 5
longueur du premier tableau de tab tab[2] = 5

Un tableau bi-dimensionnel est un tableau dont les éléments sont eux aussi des tableaux. La première dimension est représentée par tab. La deuxième dimension est représentée par tous les éléments de tab. Soit : tab[0], tab[1] et tab[2]. Et s' il y avait 3 dimensions, la troisième serait représentée par tous les éléments de tab[0], tab[1] et tab[2]. Or ici, ces éléments ne sont pas des tableaux. Donc, nous sommes bien dans un tableau bi-dimensionnel.

Attention, les éléments de tab n' ont pas forcément le même nombre d' éléments comme ici. Dans ce cas, la déclaration se fait d' une autre manière. Exemple suivant :

EXEMPLE 11 :  


1.     public class Tableaux11
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [][] tab = { new int[2], new int[3], new int[5] };
7.               
8.               System.out.println("longueur du tableau tab = " + tab.length);
9.               System.out.println("longueur du premier tableau de tab tab[0] = " + tab[0].length);
10.              System.out.println("longueur du premier tableau de tab tab[1] = " + tab[1].length);
11.              System.out.println("longueur du premier tableau de tab tab[2] = " + tab[2].length);
12.         }
13.    }

compilez puis exécutez. il sera affiché :

longueur du tableau tab = 3
longueur du premier tableau de tab tab[0] = 2
longueur du premier tableau de tab tab[1] = 3
longueur du premier tableau de tab tab[2] = 5

Longueur du tableau tab est toujours 3. En ligne 6, on voit bien dans les accolades 3 objets tableaux illustrés par new int[]. Et le nombre d' éléments de chaque tableau se voit. 2, 3 et 5. D' où l' affichage.

J' ai créé ce site dans le but premier d' aider ceux qui ont du mal à démarrer en programmation. J' ai donc pensé qu' une pédagogie basée sur des exemples serait plus digérable. C' est pourquoi je fais toujours un effort de ne pas offrir un véritable cours de programmation comme dans les livres. Seulement, les variables tableau sont un peu moins simples que vous les débutants, vous pourrier le croire. Il est donc temps que j' entre un peu plus en détail comme dans un véritable cours de prog.

La déclaration : int [] tab; est celle d' un tableau. En fait, tab n' est pas une variable tableau comme je l' ai toujours dit.Ce n' est même pas une variable dans le sens classique du mot. C' est une référence à un tableau. Qu' est-ce que ça veut dire ? ...
La mémoire d' un ordinateur n' est pas une surface sans repères. Chaque petite portion de cette surface possède une adresse (nous aurons l' occasion d' afficher une adresse mémoire en P.O.O). Cette adresse est appelée référence. L' instruction int [] tab; signifie donc : déclaration de la variable tab succeptible non pas de contenir une valeur mais pluôt une adresse (autrement dit, une référence) d' un objet tableau de type int.
La déclaration tab = new int [5]; signifie : création d' un objet tableau de 5 variables de type int. Ces variables ont la particularité d' avoir le même nom et leurs cases mémoires sont contigues. L' accès à un élément du tableau se fait en citant ce nom suivi des [] à l' intérieur desquels on met l' indice indiquant la position de l' élément. Le premier élément étant toujours d' indice zéro.
Evidement, int [] tab; et tab = new int [5]; sont deux déclarations qui peuvent se condenser en une seule : int [] tab = new int [5];
Le mot clé new permet de fabriquer les objets. On en dira plus sur les objets lorsque nous aborderons la P.O.O

Lorsqu' il s' agir d' un tableau bi-dimensionnel, la déclaration int [] [] tab; est celle d' une variable tab qui contient l' adresse ( référence) d' un ou de plusieurs objets tableaux de type int

La déclaration tab = new int [3][5]; signifie : dréation de 3 objets tableaux contenant chacun 5 éléments dont la valeur est de type int.

Lorsque les objets tableaux ont le même nombre d' éléments, on dit que le tableau est une matrice. Le nombre de lignes de cette matrice est le nombre d' objets tableaux et le nombre de colonnes de cette matrice est le nombre d' éléments de chacun des objets tableaux.

Le nombre total de valeurs du tableau bi-dimensionnel est égal au nombre de lignes multipliés par le le nombre de colonnes.

EXEMPLE 12 :  


1.     public class Tableaux12
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [][] tab = new int [3][5];
7.               for(int i = 0; i < 3; i++)
8.               {
9.                    for(int j = 0; j < 5; j++)
10.                   {
11.                        System.out.print("element " + j + " du tableau " + i + " a pour valeur " + tab[i][j] );
12.                   }
13.                   System.out.println();
14.              }
15.         }
16.    }

compilez puis exécutez, il sera affiché ceci :

element 0 du tableau 0 a pour valeur 0
element 1 du tableau 0 a pour valeur 0
element 2 du tableau 0 a pour valeur 0
element 3 du tableau 0 a pour valeur 0
element 4 du tableau 0 a pour valeur 0

element 0 du tableau 1 a pour valeur 0
element 1 du tableau 1 a pour valeur 0
element 2 du tableau 1 a pour valeur 0
element 3 du tableau 1 a pour valeur 0
element 4 du tableau 1 a pour valeur 0

element 0 du tableau 2 a pour valeur 0
element 1 du tableau 2 a pour valeur 0
element 2 du tableau 2 a pour valeur 0
element 3 du tableau 2 a pour valeur 0
element 4 du tableau 2 a pour valeur 0

Normal ! il existe 3 objets tableau dans tab. tab[0] (tableau 0), tab[1] (tableau 1) et tab[2] (tableau 2). Chacun de ces tableau possède 5 éléments.
Pour le tableau 0, ces éléments sont : tab[0][0], tab[0][1], tab[0][2], tab[0][3], tab[0][4].
Pour le tableau 1, ces éléments sont : tab[1][0], tab[1][1], tab[1][2], tab[1][3], tab[1][4].
Pour le tableau 2, ces éléments sont : tab[2][0], tab[2][1], tab[2][2], tab[2][3], tab[2][4].

Reprenons l' exemple en affichant les valeurs sous forme de matrice.

EXEMPLE 13 :  


1.     public class Tableaux13
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [][] tab = new int [3][5];
7.               for(int i = 0; i < 3; i++)
8.               {
9.                    for(int j = 0; j < 5; j++)
10.                   {
11.                        System.out.print(tab[i][j] + " " );
12.                   }
13.                   System.out.println();
14.              }
15.         }
16.    }

à l' affichage, nous auront :

0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

ligne 6 : nous déclarons une variable tableau (tab) bi-dimensionnelle. Cette variable possède 3 objets tableaux dont chacun possède 5 éléments.
Des lignes 7 à 14, on a affaire à une imbrication de 2 boucles. ligne 7 : la boucle parcours les 3 objets tableaux. Et pour chaque objet tableau, la deuxième boucle (située à l' intérieur de la première (imbriquée) ), parcours les 5 éléments de chaque tableau. La ligne 11. permet d' afficher chacune des valeurs d' un tableau sur la même ligne. C' est pourquoi j' ai utilisée print au lieu de println. Chaque valeur étant séparée par l' autre par un caractère espace. Puis la ligne 13 permet de passer à la ligne lorsqu' on a affiché tous les éléments d' un même tableau. D' où l' affichage de la matrice.

Comment faire pour afficher une tableau bi-dimensionnel dont les onjets ne possèdent pas le même nombre d' éléments ? C' est à dire, un tableau qui n' est pas une matrice ?

EXEMPLE 14 :  


1.     public class Tableaux14
2.     {
3.		
4.          public static void main (String [] args)
5.          {
6.               int [][] tab = { new int [3], new int[5], new int[4]};
7.               for(int i = 0; i < tab.length; i++)
8.               {
9.                    for(int j = 0; j < tab[i].length; j++)
10.                   {
11.                        System.out.print(tab[i][j] + " " );
12.                   }
13.                   System.out.println();
14.              }
15.         }
16.    }

à l' affichage, nous auront :

0 0 0
0 0 0 0 0
0 0 0 0

Vous avez pigé l' astuce ? La variable tab possède 3 objets tableau comme indiqués par les 3 new int[]. Puis chqua objet tableau possède son nombre d' éléments (3, 5 puis 4). L' astuce se trouve vraiment sur la 2ème boucle. Lorsque j varie de 0 à tab[i].length. En effet, Le nombre d' éléments de chaque tableau (j) varie de zéro (comme tout tableau) au nombre d' éléments de ce tableau - 1. Lorsque i = 0, nous sommes sur le tableau i tab[0]. Donc j variera de 0 à tab[0].length. C' est pourquoi l' affichage donne bien 3 valeurs en première ligne, 5 en 2ème et 4 en troisième.

Un conseil : Si vous n' avez pas compris, relisez les explications. Ce n' est pas aussi compliqué que ça pourrait avoir l' air. Et si vous avez pigé au moins un peu, ce que je crois, alors regardez les exercices consacrés aux tableaux. prochain paragraphe.