Les tableaux

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 strings
Pour 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é avec les 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 utiliser new, 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