Généralités
Un tableau (array) est un type particulier d'objet, qui contient 0 ou plusieurs instances de type référence ou primitif, que l'on appelle éléments du tableau.En résumé :
// Déclaration String[] myStrings; // Initialisation myStrings = new String[4]; // Utilisation : myStrings[2] = "toto"; System.out.println(myStrings[2]);
Les éléments d'un tableau n'ont pas de nom, ils sont repérés par leur index, qui commence à 0 :
myStrings[0], myStrings[1] ...
Type
Important : Tous les éléments d'un tableau doivent être du même type.Comme les classes ou les interfaces, les tableaux sont un type référence.
Le type d'un tableau est caractérisé par le type de ses éléments.
Donc par exemple
String[] constitue un type au même titre que n'importe quelle classe java. A ce titre, on peut utiliser un type de tableau pour sépcifier le type d'un paramètre ou du retour d'une méthode.
Par exemple
public static int max(int[] x) n'acceptera pas un tableau de float.
Mais la longueur du tableau ne fait pas partie de son type, on ne peut pas créer de type "un tableau contenant 4 strings".
Les instances d'un tableau sont donc des objets, qui héritent des méthodes de
java.lang.Object.
Taille d'un tableau
La taille du tableau doit être spécifiée à la création et ne peut pas changer.C'est une limitation importante ; pour la contourner, on utilise les collections.
Le nombre d'élément d'un tableau est stocké dans une propriété :
length.
System.out.println(myStrings.length);Les indexes vont de
0 à length - 1
Déclaration, initialisation
Pour définir un tableau on utilise les crochets (brackets)[ ] :
byte b; // declaration of a variable byte[] arrayOfBytes; // byte[] is an array of byte values byte[][] arrayOfArrayOfBytes; // byte[][] is an array of byte[] String[] points; // String[] is an array of stringsPour initialiser un tableau, on utilise le mot-clé
new, comme pour un objet :
String[] lines = new String[50];Lorsqu'on crée un tableau, chaque élément est automatiquement initialisé les valeurs par défaut correspondant au type (mêmes valeurs utilisées pour les variables d'une classe -
false pour un booléen, \u0000 pour un char, 0 un entier, 0.0 pour un nombre réel, et null pour un type référence).
Array initializers
De la même manière qu'on peut initialiser une chaîne avec une syntaxe spéciale sans utilisernew, on peut initialiser un tableau :
String[] greetings = new String[] { "Hello", "Hi", "Howdy" };
// ou plus simplement :
String[] greetings = { "Hello", "Hi", "Howdy" };
int[] smallPrimes = { 2, 3, 5, 7, 11, 13, 17, 19, };
On parle d'array litterals
Cette syntaxe permet de créer un tableau sans utiliser
new
Elle permet aussi d'utiliser des tableaux sans les assigner à des variables (en quelque sorte des "tableaux anonymes") :
double d = computeAreaOfTriangle(new Point[] { new Point(1,2), new Point(3,4), new Point(3,2) });
Les array litterals sont créés et initialisés à l'exécution, et pas à la compilation.
int[] perfectNumbers = {6, 28};
A la compilation, cela est traduit en :
int[] perfectNumbers = new int[2]; perfectNumbers[0] = 6; perfectNumbers[1] = 28;Une conséquence importante est qu'on peut mettre dans un array litterals des choses qui ne sont pas fixes, par exemple
Point[] points = { circle1.getCenterPoint(), circle2.getCenterPoint() };
Utilisation des tableaux
On utilise les brackets[ ] pour accéder aux éléments d'un tableau :
String[] responses = new String[2];
responses[0] = "Yes";
responses[1] = "No";
System.out.println(question + " (" + responses[0] + " / " + responses[1] + " ) : ");
Si t est un tableau, t[0] est son premier élément, t[1] le second ... et t[t.length-1] est le dernier.
Pour parcourir un tableau, on peut utilise typiquement une boucle for ou foreach:
int[] primes = { 2, 3, 5, 7, 11, 13, 17, 19, 23 };
int sumOfPrimes = 0;
for(int i = 0; i < primes.length; i++){
sumOfPrimes += primes[i];
}
// ou bien
for(int p : primes){
sumOfPrimes += p;
}
La classe java.util.Arrays contient de nombreuses méthodes pour manipuler les tableaux.
Tableaux à plusieurs dimensions
Un tableau peut contenir tout type d'objet, notamment des tableaux, ce qui permet de gérer des tableaux à plusieurs dimensions.S'utilisent comme les tableaux à une dimension.
Il n'est pas nécessaire de spécifier toutes les length à la création, seule la première est nécessaire, et il faut les spécifier par la gauche :
float[][][] tableau3D = new float[360][180][100]; float[][][] tableau3D = new float[360][180][]; float[][][] tableau3D = new float[360][][];Mais à l'utilisation, il faudra spécifier les tailles avant de les utiliser :
int[][] t = new int[10][];
for(int i = 0; i < t.length; i++){
t[i] = new int[i]; // ici, on a pu déclarer un tableau non "carré"
for(int j = 0; j < t[i].length; j++){
System.out.println("i = " + i + " - j = " + j);
}
System.out.println();
}
Les array initializers peuvent être aussi utilisés pour des tableaux à plusieurs dimensions :
int[][] products = {
{0, 0, 0, 0, 0},
{0, 1, 2, 3, 4},
{0, 4, 8, 12, 16}, // remarquer la dernière virgule (facultative)
};
Exercice Max et moyenne
Exercice Voitures
Exercice Nombres premiers