FAQ Langage JavaConsultez toutes les FAQ

Un tableau (ou array) est un type de stockage de données contigües similaire à ce qu'on peut trouver dans d'autres langages de programmation. Un tableau peut contenir des literals, des références d'objets, y compris des références vers d'autres tableaux. Un tableau contenant des références peut contenir la valeur null, un tableau contenant des literals ne le peut pas.

Attention : en Java, un tableau n'est pas un pointeur adressant un bloc mémoire arbitraire. Ici, il s'agit d'un objet qui hérite implicitement de la classe java.lang.Object et sur lequel il est même possible d'invoquer quelques méthodes (celles définies dans la classe Object) !

Pour déclarer un tableau en Java, vous devez spécifier un type (soit primitif, soit objet) suivi de la notation [] (crochet ouvrant suivi de crochet fermant). Par exemple :

1
2
3
int[] tableauEntier; // un tableau d'entiers. 
String[] tableauChaine; // un tableau de chaînes de caractères. 
Voiture[] tableauVoiture; // un tableau d'instances de la classe Voiture.

int[] tableauEntier = new int[10]; // Le tableau contiendra 10 éléments.

• boolean - le contenu du tableau sera initialisé à la valeur false ;
• Nombres primitifs - le contenu du tableau sera initialisé à la valeur 0, 0F, 0L ou 0D suivant le type utilisé ;
• Objets (y compris String, les classes wrapper des nombres et des sous-tableaux) - le contenu du tableau sera initialisé à la valeur null.
  

int[] tableauEntier = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // Le tableau contiendra 10 éléments.

int[] tableauEntier = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // Le tableau contiendra 10 éléments.

Pour savoir si un objet est un tableau, il suffit de faire :

boolean estUnTableau = monObjet.getClass().isArray();

Pour accéder aux éléments d'un tableau, vous devez utiliser la syntaxe <nom du tableau>[<index de la valeur>] où l'index de la valeur est un entier positif ou strictement inférieur à la taille du tableau. Cette valeur peut être une constante ou le contenu d'une variable. L'objet retourné est du même type que le contenu du tableau.

De plus, en Java, la première cellule du tableau est toujours à l'index 0. Ainsi, un tableau de taille N sera indexable par la plage d'indices [0, N-1].

Par exemple :

1
2
3
int[] tableauEntier = {1 , 2 , 3, 4, 5, 6, 7, 8, 9, 10}; 
int valeur = tableauEntier[2]; // Récupère le 3e élément du tableau (index 2). 
tableauEntier[0] = 5; // Modifie la valeur du 1er élément du tableau (index 0).

Chaque tableau, qu'il contienne des primitifs ou des références vers des objets dispose d'un membre length qui contient la taille du tableau sous forme d'une valeur entière positive ou nulle. Ce membre a le modificateur final et n'est donc pas modifiable.

Ainsi, il est possible de faire :

1
2
int[] tableau = {1, 2, 3}; 
System.out.println(tableau.length); // Imprime 3 sur la console.

Il est impossible de changer la taille d'un tableau : la taille d'un tableau est fixe et ne peut pas être modifiée une fois que le tableau a été instancié.

Vous devez donc allouer un nouveau tableau à la taille appropriée et recopier le contenu de l'ancien tableau dans le nouveau. La méthode publique statique arraycopy() de la classe java.lang.System peut être utilisée à cet effet. Par exemple :

1
2
3
4
5
public int[] doubleLaTaille(final int[] source) { 
    final int[] result = new int[source.length * 2];  
    System.arraycopy(source, 0, result, 0, source.length); // Recopie le contenu de la source au début du résultat. 
    return result; 
}

Dans les spécifications du langage Java, il est indiqué que, pour indexer un élément dans un tableau, il faut utiliser une valeur entière positive ou nulle.

En théorie, cela implique donc que le tableau contient au maximum 2³¹-1 éléments soit la valeur Integer.MAX_VALUE, le plus grand entier positif possible. La plus grande plage d'indices possible pour un tableau est donc [0, 2³¹-2]. Cependant, il s'agit d'une limite théorique.

En pratique, dans les JVM récentes, il semble qu'il ne soit pas possible d'allouer un tableau dont la taille dépasse Integer.MAX_VALUE - 2. Toute tentative d'allouer une taille supérieure à cette limite se soldera par une erreur de type java.lang.OutOfMemoryError contenant le message « Requested array size exceeds VM limit ». Même si la valeur est dans la limite supportée, une erreur java.lang.OutOfMemoryError contenant le message « Java heap space » peut être générée si la JVM échoue à allouer assez de mémoire pour créer un tel tableau en fonction du type des données stockées dans le tableau.

1
2
3
4
5
6
7
8
 // Un tableau de N bytes consomme N octets en mémoire. 
final byte[] test = new byte[Integer.MAX_VALUE]; // Échoue avec java.lang.OutOfMemoryError: Requested array size exceeds VM limit 
final byte[] test = new byte[Integer.MAX_VALUE-1]; // Échoue avec java.lang.OutOfMemoryError: Requested array size exceeds VM limit 
final byte[] test = new byte[Integer.MAX_VALUE-2]; // Fonctionne, 
// Un tableau de N int consomme 4 * N octets en mémoire. 
final int[] test = new int[Integer.MAX_VALUE]; // Échoue avec java.lang.OutOfMemoryError: Requested array size exceeds VM limit 
final int[] test = new int[Integer.MAX_VALUE-1]; // Échoue avec java.lang.OutOfMemoryError: Requested array size exceeds VM limit 
final int[] test = new int[Integer.MAX_VALUE-2]; // Échoue avec java.lang.OutOfMemoryError: Java heap space

Il existe de très nombreuses manières de parcourir tous les éléments d'un tableau. Nous allons en aborder quelques-unes des plus courantes :

Boucle for ou while
Nous pouvons effectuer le parcours à l'ancienne, avec une boucle for traditionnelle, par exemple :

1
2
3
4
5
int[] tab = new int[50] 
[...] 
for (int index = 0; index < tab.length; index++) { 
    System.out.println(tab[index]); 
}

1
2
3
4
5
6
7
int[] tab = new int[50] 
[...] 
int index = 0; 
while (index < tab.length) { 
    System.out.println(tab[index]); 
    index++; 
}

1
2
3
4
5
int[] tab = new int[50] 
[...] 
for (int n : tab) { 
    System.out.println(n); 
}

1
2
3
4
int[] tab = new int[50] 
[...] 
IntStream.range(0, tab.length) 
    .forEach(index -> System.out.println(tab[index]));

1
2
3
4
int[] tab = new int[50]; 
[...] 
Arrays.stream(tab) 
    .forEach(System.out::println);

Java ne supporte pas les tableaux multidimensionnels en tant que bloc mémoire unifié comme peuvent le faire d'autres langages. Il reste cependant possible de créer des tableaux de tableaux qui peuvent jouer un rôle similaire pour simuler des tableaux à dimensions multiples.

Pour indiquer que votre variable contient plus d'une seule dimension, il suffit de rajouter dans sa déclaration de type autant de [] qu'il y a de dimensions supplémentaires. Par exemple :

1
2
int[][] matriceEntiere2D; 
String[][][] matriceChaine3D;

1
2
int[][] matriceEntiere2D = new int[10][]; 
int[][] matriceEntiere2D = new int[][10]; // Erreur.

1
2
System.out.println(matriceEntiere2D[5])); // Imprime null. 
System.out.println(matriceEntiere2D[5][3])); // génère une NullPointerException.

1
2
3
4
int[][] matriceEntiere2D = new int[10][]; 
for (int i = 0 ; i < 10 ; i++) { 
    matriceEntiere2D[i] = new int[10]; // Initialisation des sous-tableaux. 
}

int[][] matriceEntiere2D = new int[10][10];

String[][] matriceChaine2D = {{"Foo", "Fii"}, {"Faa", "Fuu"}};

1
2
3
4
5
int[][] matriceEntier2D = new int[10][10]; 
int valeur = matriceEntier2D[5][7]; // Vaut 0. 
int[] vecteur = matriceEntier2D[8]; // Vaut [0,0,0,0,0,0,0,0,0,0]. 
matriceEntier2D[2][1] = 8; 
matriceEntier2D[1][6] = null;

Cette propriété n'est pas directement accessible, mais la fonction suivante permet de la calculer rapidement. On se base sur le fait qu'un tableau à plusieurs dimensions est en fait un tableau de tableaux.

1
2
3
4
5
6
7
8
9
public static int getNbDimension(Object monTableau) { 
    int dim=0; 
    Class cls = monTableau.getClass(); 
    while( cls.isArray()) { 
        cls = cls.getComponentType(); 
        dim++; 
    }  
    return( dim ); 
}

Le code suivant permet de parcourir un tableau à deux dimensions d'entiers et de les afficher :

1
2
3
4
5
6
int tab[][] = { {1, 2, 3}, {7, 8, 9} };  
for(int ligne[] : tab) { 
    for(int element : ligne) { 
        System.out.println("Item : " + element); 
    } 
}

Pour trier le contenu d'un tableau, vous devez invoquer une des variantes de la méthode sort() de la classe utilitaire java.util.Arrays :

1
2
3
4
5
6
7
8
int[] unTableauDEntiers = [...] 
Arrays.sort(unTableauDEntiers); 
  
float[] unTableauDeFlottants= [...] 
Arrays.sort(unTableauDeFlottants); 
  
Voiture[] unTableauDeVoitures = [...] 
Arrays.sort(unTableauDeVoitures);

1
2
Comparator<Voiture> comparateurDePuissance = [...] // Compare le nombre de chevaux au lieu du nom de la voiture. 
Arrays.sort(unTableauDeVoitures, comparateurDePuissance );

Contrairement à ce qu'on pourrait penser, il est possible de créer des instances de tableaux génériques. Il suffit pour cela d'invoquer une des variantes de la méthode publique statique newInstance() de la classe java.lang.reflect.Array. La première version de la méthode permet de créer un tableau classique à une dimension, tandis que la seconde version permet de spécifier de multiples dimensions. Dans les deux cas, il faut cependant détenir une référence vers la classe que nous désirons stocker dans le tableau.

Ainsi il est possible de faire :

String[] tableau = (String[])Array.newInstance(String.class, 100);

T[] tableau = (T[])Array.newInstance(uneValeurDeTypeT.getClass(), 100);

Le compilateur interdit toute création de tableaux de type paramétré, ainsi la ligne suivante provoquera irrémédiablement une erreur :

List<String> stringListArray[] = new List<String>[100];

1
2
3
4
5
List<String>[] stringListArray = new List<String>[100]; // ERREUR 
  
Object[] simpleArray = stringListArray; 
  
simpleArray[0] = new ArrayList<Number>(); // OK ?!?!?

1
2
3
4
5
List<List<String>> stringListList = new ArrayList<List<String>>(); 
  
List simpleList = stringListList; 
  
simpleList.add( new ArrayList<Number>() ); // Warning unchecked

1
2
@SuppressWarnings("unchecked") 
List<String>[] stringListArray = new List[100];