Dans cette section, vous allez apprendre à utiliser les tableaux en Java. Les tableaux permettent de stocker plusieurs valeurs du même type dans une structure ordonnée. Vous découvrirez comment déclarer, initialiser et parcourir des tableaux, ce qui est essentiel pour manipuler des collections de données.

3.3Tableaux

3.3.1 – Déclaration et initialisation

Un tableau est une structure de données qui permet de stocker plusieurs valeurs du même type dans une séquence ordonnée. Chaque élément est accessible par son index (position dans le tableau).

📦 Déclaration d'un tableau

Il existe plusieurs façons de déclarer un tableau en Java :

Méthode 1 : Déclaration puis initialisation

// Déclarer un tableau d'entiers
int[] nombres;

// Initialiser avec une taille
nombres = new int[5];  // Tableau de 5 entiers (valeurs par défaut : 0)

Méthode 2 : Déclaration et initialisation en une ligne

int[] nombres = new int[5];  // Tableau de 5 entiers

Méthode 3 : Initialisation avec valeurs

int[] nombres = {10, 20, 30, 40, 50};  // Tableau avec valeurs initiales

📊 Types de tableaux

Exemples avec différents types :

// Tableau d'entiers
int[] nombres = {1, 2, 3, 4, 5};

// Tableau de chaînes
String[] noms = {"Alice", "Bob", "Charlie"};

// Tableau de caractères
char[] lettres = {'A', 'B', 'C'};

// Tableau de booléens
boolean[] etats = {true, false, true};

// Tableau de décimaux
double[] prix = {19.99, 29.99, 39.99};

🔢 Accès aux éléments

Les éléments d'un tableau sont accessibles par leur index. Important : Les indices commencent à 0, pas à 1 !

Exemple : Accès et modification

int[] nombres = {10, 20, 30, 40, 50};

// Accéder à un élément
int premier = nombres[0];   // 10
int deuxieme = nombres[1];  // 20
int dernier = nombres[4];    // 50

// Modifier un élément
nombres[0] = 100;  // Le tableau devient {100, 20, 30, 40, 50}

// Longueur du tableau
int taille = nombres.length;  // 5

Important :

Les indices commencent à 0
Le dernier indice est tableau.length - 1
Accéder à un indice invalide provoque une ArrayIndexOutOfBoundsException

📏 Taille fixe des tableaux

Une fois créé, la taille d'un tableau ne peut pas être modifiée :

int[] nombres = new int[5];  // Tableau de taille 5

// nombres.length est toujours 5
// Vous ne pouvez pas "agrandir" ou "rétrécir" le tableau

// Pour "changer" la taille, il faut créer un nouveau tableau
int[] nouveauxNombres = new int[10];  // Nouveau tableau de taille 10

💡 Points clés à retenir

Déclaration : type[] nomTableau; ou type nomTableau[];
Initialisation : new type[taille] ou {valeur1, valeur2, ...}
Indices : Commencent à 0, dernier indice = length - 1
Taille fixe : Une fois créé, la taille ne peut pas changer
length : Propriété (pas méthode) qui donne la taille
Valeurs par défaut : 0 pour int, 0.0 pour double, false pour boolean, null pour objets

3.3.2 – Parcours d'un tableau

Parcourir un tableau signifie accéder à chaque élément du tableau, un par un. Il existe plusieurs méthodes pour parcourir un tableau en Java.

🔄 Méthode 1 : Boucle for classique

La méthode la plus courante utilise une boucle for avec un index :

Exemple : Afficher tous les éléments

int[] nombres = {10, 20, 30, 40, 50};

for (int i = 0; i < nombres.length; i++) {
    System.out.println(nombres[i]);
}

// Affiche :
// 10
// 20
// 30
// 40
// 50

🔄 Méthode 2 : Boucle for-each (améliorée)

La boucle for-each est plus simple et plus sûre (pas de risque d'erreur d'index) :

Exemple : Parcourir avec for-each

int[] nombres = {10, 20, 30, 40, 50};

for (int nombre : nombres) {
    System.out.println(nombre);
}

// Équivalent à la boucle for classique mais plus simple

📝 Exemples pratiques

Exemple 1 : Calculer la somme

int[] nombres = {10, 20, 30, 40, 50};
int somme = 0;

for (int nombre : nombres) {
    somme += nombre;
}

System.out.println("Somme : " + somme);  // 150

Exemple 2 : Trouver le maximum

int[] nombres = {10, 25, 5, 30, 15};
int max = nombres[0];  // Initialiser avec le premier élément

for (int i = 1; i < nombres.length; i++) {
    if (nombres[i] > max) {
        max = nombres[i];
    }
}

System.out.println("Maximum : " + max);  // 30

Exemple 3 : Rechercher un élément

int[] nombres = {10, 20, 30, 40, 50};
int recherche = 30;
boolean trouve = false;

for (int nombre : nombres) {
    if (nombre == recherche) {
        trouve = true;
        break;  // Sortir de la boucle si trouvé
    }
}

if (trouve) {
    System.out.println("Élément trouvé !");
} else {
    System.out.println("Élément non trouvé.");
}

Exemple 4 : Modifier tous les éléments

int[] nombres = {10, 20, 30, 40, 50};

// Multiplier tous les éléments par 2
for (int i = 0; i < nombres.length; i++) {
    nombres[i] = nombres[i] * 2;
}

// Le tableau devient : {20, 40, 60, 80, 100}

Note : Pour modifier les éléments, vous devez utiliser la boucle for classique avec index, pas for-each.

📊 Comparaison : for classique vs for-each

Critère	for classique	for-each
Accès à l'index	Oui (variable i)	Non
Modification d'éléments	Oui	Non (lecture seule)
Simplicité	Moins simple	Plus simple
Sécurité	Risque d'erreur d'index	Aucun risque
Parcours partiel	Possible (i = 2; i < 5)	Non (parcourt tout)

🔄 Parcours en sens inverse

int[] nombres = {10, 20, 30, 40, 50};

// Parcourir de la fin vers le début
for (int i = nombres.length - 1; i >= 0; i--) {
    System.out.println(nombres[i]);
}

// Affiche : 50, 40, 30, 20, 10

💡 Points clés à retenir

for classique : Accès à l'index, permet de modifier les éléments
for-each : Plus simple, lecture seule, pas d'accès à l'index
Parcours complet : De 0 à length - 1
Parcours inverse : De length - 1 à 0
Modification : Utiliser for classique avec index
Lecture : Utiliser for-each pour plus de simplicité

Conseil pratique : Utilisez for-each quand vous voulez seulement lire les éléments. Utilisez for classique quand vous devez modifier les éléments ou avoir accès à l'index.