int[][] t2={ {10,17,8,9,10,20,13,11,7,5}, // 0,0 à 0,9 
{9,14,2,0,18,10,16,19,18,6}, // 1,0 à 1,9 
{17,8,9,7,10,12,11,14,11}} ; // 2,0 à 2,8
La  taille  de  chaque  dimension  d’un  tableau  peut  être  récupérée  avec  la  propriété  length.  Cependant  attention,  vous 
n’obtiendrez pas le nombre total d’éléments de tout le tableau, mais pour chaque dimension. L’exemple suivant met ceci en 
lumière pour un tableau à deux dimensions. Pour obtenir le nombre d’éléments de chaque dimension, récupérez la propriété 
length pour chacune de ces dimensions : 
class chap5_2dim { 
public static void main(String[] args) { 
int[][] t=new int[3][]; 
int i,total=0; 
 
t[0]=new int[10]; 
t[1]=new int[8]; 
t[2]=new int[9]; 
 
System.out.println(t.length); // 1ere dimension 
 
for(i=0;i total+=t[i].length; // calcul nb total d’elements 
System.out.println(t[i].length); 
} 
System.out.println(total); 
} 
}
3. Représentation en mémoire 
a. Représentation linéaire 
En principe, les éléments d’un tableau sont placés dans des cases contiguës en mémoire. Si vous prenez un tableau de dix 
nombres, il pourrait être représenté ainsi : 
La  case  est  le  numéro  de  la  case  mémoire,  l’indice  le  numéro  dans  le  tableau  et  la  valeur  la  note  associée  à  l’indice.  Une 
constatation s’impose d’elle­même : les numéros des cases mémoire (les adresses) n’ont pas de rapport avec l’indice, mis à 
part le fait qu’ils sont contiguës. 
Autant se représenter un tableau de scalaires à une dimension (un seul indice) en mémoire est simple, autant se représenter 
deux ou n dimensions devient un peu moins évident, d’autant plus que cette représentation peut varier d’un langage à un 
autre. Comme le nombre maximal d’indice est connu à l’avance (dans le cas du pseudo­code algorithmique), un tableau à deux 
dimensions peut être facilement transposé en tableau à une seule dimension. 
Soit un tableau note[1..3][1..5] : deux dimensions, qui représentent quinze valeurs. Voici comment ceci pourrait être représenté 
en mémoire : 
La première ligne représente l’adresse de la case mémoire associée aux différents indices du tableau. Cette valeur est bien 
entendu entièrement arbitraire et est connue du langage mettant en œuvre le tableau. 
La deuxième ligne représente les indices des différents éléments du tableau. Remarquez que dans cette représentation, on 
commence  par  la  première  dimension,  puis  par  la  deuxième,  etc.  Un  tableau  à  n  dimensions  peut  donc  être  représenté  de 
manière totalement linéaire. Il est pratique en débutant de se représenter un tableau à deux dimensions en termes de lignes 
et de colonnes. Mais cette vue de l’esprit est totalement fausse : la mémoire en tant que telle ne peut être représentée ainsi, 
elle est linéaire (le fameux ruban). Un tableau s’étale donc linéairement dans la mémoire, d’une manière ou d’une autre. Cette 
dernière remarque est sujette à caution comme vous le verrez un peu plus bas. 
Dans le cas du tableau à deux dimensions, comment un langage utilisant ce principe peut connaître la position exacte d’un 
élément en mémoire ? Soit : 
Case 
13121 
13122 
13123 
13124 
13125 
13126 
13127 
13128 
13129 
13130 
Indice 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
Valeur 
15 
17 
8 
13 
10 
6 
9 
13 
14 
11 
Adr 
143 
144 
145 
146 
147 
148 
149 
150 
151 
152 
153 
154 
155 
156 
157 
Ind 
1,1 
1,2 
1,3 
1,4 
1,5 
2,1 
2,2 
2,3 
2,4 
2,5 
3,1 
3,2 
3,3 
3,4 
3,5 
Val 
10 
7 
14 
8 
12 
11 
5 
12 
13 
18 
20 
2 
0 
17 
16 
- 6 -
© ENI Editions - All rigths reserved - Jonifar lina
100