10. Tableaux en Java

Table des matières

• 10.1 Ce qu’est un tableau
  • 10.1.1 Déclarer des tableaux
  • 10.1.2 Créer des tableaux (instanciation)
  • 10.1.3 Valeurs par défaut dans les tableaux
  • 10.1.4 Accéder aux éléments
  • 10.1.5 Raccourcis d’initialisation de tableaux
    • 10.1.5.1 Création anonyme de tableau
    • 10.1.5.2 Syntaxe courte (uniquement à la déclaration)
• 10.2 Tableaux multidimensionnels (tableaux de tableaux)
  • 10.2.1 Créer un tableau rectangulaire
  • 10.2.2 Créer un tableau dentelé (irrégulier)
• 10.3 Longueur d’un tableau vs longueur d’une chaîne
• 10.4 Affectations de références de tableaux
  • 10.4.1 Affecter des références compatibles
  • 10.4.2 Affectations incompatibles (erreurs à la compilation)
  • 10.4.3 Danger d’exécution de la covariance : ArrayStoreException
• 10.5 Comparer des tableaux
• 10.6 Méthodes utilitaires de Arrays
  • 10.6.1 Arrays.toString
  • 10.6.2 Arrays.deepToString pour les tableaux imbriqués
  • 10.6.3 Arrays.sort
  • 10.6.4 Arrays.binarySearch
  • 10.6.5 Arrays.compare
• 10.7 Boucle for améliorée avec les tableaux
• 10.8 Pièges courants
• 10.9 Résumé

---

10.1 Ce qu’est un tableau

Les tableaux en Java sont des collections à taille fixe, indexées, ordonnées d’éléments du même type.

Ce sont des objets, même lorsque les éléments sont des primitifs.

10.1.1 Déclarer des tableaux

Vous pouvez déclarer un tableau de deux façons :

int[] a;      // preferred modern syntax
int b[];      // legal, older style
String[] names;
Person[] people;

// [] can be before or after the name: all the following declarations are equivalent.

int[] x;
int [] x1;
int []x2;
int x3[];
int x5 [];

// MULTIPLE ARRAY DECLARATIONS

int[] arr1, arr2;   // Declares two arrays of int

// WARNING:
// Here arr1 is an int[] and arr2 is just an int (NOT an array!)
int arr1[], arr2;

Déclarer ne crée PAS le tableau — cela crée seulement une variable capable d’en référencer un.

10.1.2 Créer des tableaux (instanciation)

Un tableau est créé en utilisant new suivi du type des éléments et de la longueur du tableau :

int[] numbers = new int[5];
String[] words = new String[3];

Règles clés - La longueur doit être non négative et spécifiée au moment de la création. - La longueur ne peut pas être modifiée ensuite. - La longueur du tableau peut être n’importe quelle expression int.

int size = 4;
double[] values = new double[size];

• Exemples illégaux de création de tableau :

// int length = -1;           
// int[] arr = new int[-1];   // Runtime: NegativeArraySizeException

// int[] arr = new int[2.5];  // Compile error: size must be int

10.1.3 Valeurs par défaut dans les tableaux

Les tableaux (puisque ce sont des objets) reçoivent toujours une initialisation par défaut :

Type d’élément	Valeur par défaut
Numérique	0
boolean	false
char	'\u0000'
Types référence	null

• Exemple :

int[] nums = new int[3]; 
System.out.println(nums[0]); // 0

String[] s = new String[3];
System.out.println(s[0]);    // null

10.1.4 Accéder aux éléments

On accède aux éléments en utilisant une indexation à base zéro :

int[] a = new int[3];
a[0] = 10;
a[1] = 20;
System.out.println(a[1]); // 20

Exception courante
- ArrayIndexOutOfBoundsException (à l’exécution)

// int[] x = new int[2];
// System.out.println(x[2]); // ❌ index 2 out of bounds

10.1.5 Raccourcis d’initialisation de tableaux

10.1.5.1 Création anonyme de tableau

int[] a = new int[] {1,2,3};

10.1.5.2 Syntaxe courte (uniquement à la déclaration)

int[] b = {1,2,3};

La syntaxe courte {1,2,3} ne peut être utilisée qu’au moment de la déclaration.

// int[] c;
// c = {1,2,3};  // ❌ does not compile

---

10.2 Tableaux multidimensionnels (tableaux de tableaux)

Java implémente les tableaux multi-dimensionnels comme des tableaux de tableaux.

Déclaration :

int[][] matrix;
String[][][] cube;

10.2.1 Créer un tableau rectangulaire

int[][] rect = new int[3][4]; // 3 rows, 4 columns each

10.2.2 Créer un tableau dentelé (irrégulier)

Vous pouvez créer des lignes de longueurs différentes :

int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[5];
jagged[2] = new int[1];

---

10.3 Longueur d’un tableau vs longueur d’une chaîne

• Les tableaux utilisent .length (champ public final).
• Les chaînes utilisent .length() (méthode).

Tip

C’est un piège classique: champs vs méthodes.

// int x = arr.length;   // OK
// int y = s.length;     // ❌ does not compile: missing ()
int yOk = s.length();

---

10.4 Affectations de références de tableaux

10.4.1 Affecter des références compatibles

int[] a = {1,2,3};
int[] b = a; // both now point to the same array

Modifier une référence affecte l’autre :

b[0] = 99;
System.out.println(a[0]); // 99

10.4.2 Affectations incompatibles (erreurs à la compilation)

// int[] x = new int[3];
// long[] y = x;     // ❌ incompatible types

Les références de tableaux suivent les règles normales d’héritage :

String[] s = new String[3];
Object[] o = s;      // OK: arrays are covariant

10.4.3 Danger d’exécution de la covariance : ArrayStoreException

Object[] objs = new String[3];
// objs[0] = Integer.valueOf(5); // ❌ ArrayStoreException at runtime

---

10.5 Comparer des tableaux

== compare les références (identité) :

int[] a = {1,2};
int[] b = {1,2};
System.out.println(a == b); // false

equals() sur les tableaux ne compare pas le contenu (il se comporte comme ==) :

System.out.println(a.equals(b)); // false

Pour comparer le contenu, utilisez des méthodes de java.util.Arrays :

Arrays.equals(a, b);         // shallow comparison
Arrays.deepEquals(o1, o2);   // deep comparison for nested arrays

---

10.6 Méthodes utilitaires de Arrays

10.6.1 Arrays.toString()

System.out.println(Arrays.toString(new int[]{1,2,3})); // [1, 2, 3]

10.6.2 Arrays.deepToString() (pour les tableaux imbriqués)

System.out.println(Arrays.deepToString(new int[][] {{1,2},{3,4}}));
// [[1, 2], [3, 4]]

10.6.3 Arrays.sort()

int[] a = {4,1,3};
Arrays.sort(a); // [1, 3, 4]

Tip

• Les chaînes sont triées selon l’ordre naturel (lexicographique).
• Les nombres sont triés avant les lettres, et les lettres majuscules sont triées avant les minuscules (nombres < majuscules < minuscules).
• Pour les types référence, null est considéré plus petit que toute valeur non nulle.

String[] arr = {"AB", "ac", "Ba", "bA", "10", "99"};

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));  // [10, 99, AB, Ba, ac, bA]

10.6.4 Arrays.binarySearch()

Exigences : le tableau doit être trié selon le même ordre ; sinon le résultat est imprévisible.

int[] a = {1,3,5,7};
int idx = Arrays.binarySearch(a, 5); // returns 2

Quand la valeur n’est pas trouvée, binarySearch renvoie -(insertionPoint) - 1 :

int pos = Arrays.binarySearch(a, 4); // returns -3
// Insertion point is index 2 → -(2) - 1 = -3

10.6.5 Arrays.compare()

La classe Arrays propose un equals() surchargé qui vérifie si deux tableaux contiennent les mêmes éléments (et ont la même longueur) :

System.out.println(Arrays.equals(new int[] {200}, new int[] {100}));        // false
System.out.println(Arrays.equals(new int[] {200}, new int[] {200}));        // true
System.out.println(Arrays.equals(new int[] {200}, new int[] {100, 200}));   // false

Elle fournit aussi une méthode compare() avec ces règles :

• Si le résultat n < 0 → le premier tableau est considéré “plus petit” que le second.
• Si le résultat n > 0 → le premier tableau est considéré “plus grand” que le second.

• Si le résultat n == 0 → les tableaux sont égaux.

• Exemples :

int[] arr1 = new int[] {200, 300};
int[] arr2 = new int[] {200, 300, 400};
System.out.println(Arrays.compare(arr1, arr2));  // -1

int[] arr3 = new int[] {200, 300, 400};
int[] arr4 = new int[] {200, 300};
System.out.println(Arrays.compare(arr3, arr4));  // 1

String[] arr5 = new String[] {"200", "300", "aBB"};
String[] arr6 = new String[] {"200", "300", "ABB"};
System.out.println(Arrays.compare(arr5, arr6));     // Positive: "aBB" > "ABB"

String[] arr7 = new String[] {"200", "300", "ABB"};
String[] arr8 = new String[] {"200", "300", "aBB"};
System.out.println(Arrays.compare(arr7, arr8));     // Negative: "ABB" < "aBB"

String[] arr9 = null;
String[] arr10 = new String[] {"200", "300", "ABB"};
System.out.println(Arrays.compare(arr9, arr10));    // -1 (null considered smaller)

---

10.7 Boucle for améliorée avec les tableaux

for (int value : new int[]{1,2,3}) {
    System.out.println(value);
}

Règles - Le côté droit doit être un tableau ou un Iterable. - Le type de la variable de boucle doit être compatible avec le type d’élément (pas d’élargissement de primitifs ici).

Erreur courante :

// for (long v : new int[]{1,2}) {} // ❌ not allowed: int elements cannot be assigned to long in enhanced for-loop

---

10.8 Pièges courants

• Accès hors limites → lance ArrayIndexOutOfBoundsException.

• Mauvaise utilisation de l’initialiseur court

// int[] x;
// x = {1,2}; // ❌ does not compile

• Confondre .length et .length()

• Oublier que les tableaux sont des objets (ils vivent sur le heap et sont référencés).

• Mélanger des tableaux de primitifs et des tableaux de wrappers

// int[] p = new Integer[3]; // ❌ incompatible

• Utiliser binarySearch sur des tableaux non triés → résultats imprévisibles.
• Exceptions d’exécution dues aux tableaux covariants (ArrayStoreException).

---

10.9 Résumé

Les tableaux en Java sont :

• Des objets (même s’ils contiennent des primitifs).
• Des collections indexées à taille fixe.
• Toujours initialisés avec des valeurs par défaut.
• Type-safe, mais soumis aux règles de covariance (ce qui peut provoquer des exceptions à l’exécution si mal utilisé).