Manipulation de tableaux unidimensionnels

1. Qu'est-ce qu'un tableau ?

Imaginez que vous deviez stocker les notes de 10 étudiants. Créer 10 variables distinctes (note1, note2, etc.) serait fastidieux et peu pratique. Un tableau résout ce problème.

Un tableau (ou array en anglais) est une structure de données qui contient un nombre fixe de valeurs du même type. On peut le voir comme une série de cases numérotées, où chaque case contient une valeur.

Les caractéristiques clés d'un tableau en Java sont :

• Taille fixe : Une fois un tableau créé, sa taille ne peut plus être modifiée.
• Type homogène : Il ne peut contenir que des éléments du même type (par exemple, que des int ou que des String).
• Accès par indice : On accède à chaque élément via sa position, appelée "indice" (ou index).

L'image suivante illustre un tableau de 10 éléments. Observez bien deux points cruciaux :

1. La longueur (length) du tableau est 10.
2. Les indices vont de 0 à 9. En Java, l'indexation commence toujours à 0.

2. Déclaration et Initialisation d'un tableau

Pour utiliser un tableau, il faut d'abord le déclarer, puis l'initialiser. La vidéo suivante vous montre très concrètement comment faire.

Synthétisons les différentes manières de déclarer et initialiser un tableau.

Syntaxe de Déclaration

Il y a deux façons de déclarer une variable de type tableau, mais la première est la plus courante et recommandée en Java car elle associe le type int[] (tableau d'entiers) au nom de la variable de manière plus claire.

// Méthode recommandée
int[] monTableau;

// Méthode possible mais moins courante (héritée du C/C++)
int monAutreTableau[]; 

Méthodes d'Initialisation

Une fois déclaré, le tableau doit être initialisé pour pouvoir être utilisé.

1. Avec le mot-clé new et une taille définie :
   C'est la méthode à utiliser quand vous connaissez la taille nécessaire, mais pas encore les valeurs. Les éléments sont alors initialisés avec une valeur par défaut (0 pour les types numériques, false pour les boolean, et null pour les objets).

   // Crée un tableau de 5 entiers, initialisés à 0.
   int[] scores = new int[5]; 
   

2. Avec une liste d'initialisation :
   C'est la méthode la plus concise quand vous connaissez déjà toutes les valeurs à insérer dans le tableau.

   // Crée et initialise un tableau de 3 chaînes de caractères.
   String[] noms = { "Alice", "Bob", "Charlie" };
   

La ressource suivante résume très bien ces différentes syntaxes.

3. Manipuler les éléments d'un tableau

Accéder et modifier un élément

Comme vu précédemment, on utilise la notation tableau[indice] pour lire ou écrire une valeur.

int[] notes = new int[3]; // Crée le tableau {0, 0, 0}

// Modifier des éléments
notes[0] = 15; // Le tableau devient {15, 0, 0}
notes[1] = 12; // Le tableau devient {15, 12, 0}

// Accéder à un élément pour l'afficher
System.out.println("La première note est : " + notes[0]); // Affiche 15

// Utiliser un élément dans un calcul
int sommeDeuxNotes = notes[0] + notes[1]; // sommeDeuxNotes vaut 27

Obtenir la taille d'un tableau

Pour connaître le nombre d'éléments qu'un tableau peut contenir, on utilise sa propriété length. Attention, length est une propriété, pas une méthode, il n'y a donc pas de parenthèses ().

String[] jours = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"};
System.out.println("Il y a " + jours.length + " jours dans la semaine."); // Affiche 7

L'erreur à ne pas commettre : ArrayIndexOutOfBoundsException

Que se passe-t-il si vous essayez d'accéder à jours[7] dans l'exemple ci-dessus ? Le tableau a 7 éléments, donc les indices valides sont de 0 à 6. Tenter d'accéder à un indice en dehors de cette plage (-1, 7, 100...) provoquera une erreur à l'exécution qui plantera votre programme : ArrayIndexOutOfBoundsException. C'est l'une des erreurs les plus fréquentes pour les débutants.

4. Parcourir un tableau

Il est très courant de vouloir effectuer une opération sur chaque élément d'un tableau. Pour cela, on utilise une boucle.

La boucle for classique

Cette boucle vous donne un contrôle total car vous manipulez directement l'indice. C'est la méthode à privilégier si vous avez besoin de l'indice (par exemple, pour modifier l'élément à la position i).

double[] prix = {19.99, 25.50, 12.75};
System.out.println("Liste des prix :");
for (int i = 0; i < prix.length; i++) {
    System.out.println("Prix de l'article " + i + " : " + prix[i] + " €");
}

La boucle for-each (ou "améliorée")

Cette syntaxe, plus moderne et plus lisible, est idéale lorsque vous avez simplement besoin de lire chaque élément sans vous soucier de sa position. Elle évite tout risque d'erreur ArrayIndexOutOfBoundsException.

System.out.println("Liste des prix (avec for-each) :");
for (double unPrix : prix) {
    System.out.println(unPrix + " €");
}

Cette boucle se lit : "Pour chaque double unPrix dans le tableau prix...".

5. Les tableaux sont des objets

Voici un point fondamental, surtout avec votre expérience en Python ou PHP où les structures de données peuvent se comporter différemment. En Java, les tableaux sont des objets. Cela signifie qu'une variable de type tableau ne contient pas le tableau lui-même, mais une référence (une adresse mémoire) vers l'objet tableau.

L'implication la plus importante concerne l'affectation.

int[] tableauA = { 10, 20, 30 };
int[] tableauB = tableauA; // On copie la référence, PAS les valeurs !

tableauB[0] = 99; // On modifie le tableau via la référence B...

// ... la modification est visible via la référence A !
System.out.println(tableauA[0]); // Affiche 99

tableauA et tableauB pointent vers le même et unique objet tableau en mémoire.

La vidéo suivante illustre parfaitement ce concept. C'est un point crucial pour éviter de futures surprises.

6. Exercice pratique

Mettez en pratique ce que vous venez d'apprendre.

Objectif : Créer une classe CalculMoyenne qui :

1. Déclare et initialise un tableau de double nommé notes avec les 5 valeurs suivantes : 12.5, 18.0, 7.5, 15.0, 10.0.
2. Utilise une boucle (for ou for-each) pour calculer la somme de toutes les notes.
3. Calcule la moyenne des notes (moyenne = somme / nombre de notes).
4. Affiche la somme et la moyenne avec un message clair.
5. Bonus : Utilise une seconde boucle pour trouver et afficher la note la plus élevée.

Conseils :

• Utilisez la propriété length pour obtenir le nombre de notes.
• Pour le bonus, initialisez une variable max avec la première note du tableau avant de commencer la boucle de recherche.

public class CalculMoyenne {

    public static void main(String[] args) {
        double[] notes = {12.5, 18.0, 7.5, 15.0, 10.0};
        double somme = 0.0;

        // 1. Calcul de la somme
        for (double note : notes) {
            somme += note;
        }

        // 2. Calcul de la moyenne
        double moyenne = somme / notes.length;

        System.out.println("Les notes sont :");
        for(int i = 0; i < notes.length; i++) {
            System.out.println("Note " + (i+1) + " : " + notes[i]);
        }
        
        System.out.println("\nSomme des notes : " + somme);
        System.out.println("Moyenne des notes : " + moyenne);

        // 3. Bonus : Trouver la note maximale
        double noteMax = notes[0]; // On suppose que la première est la plus haute au départ
        for (int i = 1; i < notes.length; i++) {
            if (notes[i] > noteMax) {
                noteMax = notes[i];
            }
        }
        
        System.out.println("Note la plus élevée : " + noteMax);
    }
}

Conclusion

Félicitations ! Vous maîtrisez maintenant les bases des tableaux en Java, une structure de données omniprésente en programmation.

Points clés à retenir :

• Un tableau a une taille fixe et contient des éléments de même type.
• L'indexation commence à 0 et va jusqu'à length - 1.
• On accède à un élément avec monTableau[indice].
• Tenter un accès hors des bornes lève une ArrayIndexOutOfBoundsException.
• La boucle for-each est parfaite pour une lecture simple, la boucle for classique est nécessaire si l'on a besoin de l'indice.
• Les tableaux sont des objets, et les variables de tableau contiennent des références.

Le principal inconvénient des tableaux est leur taille fixe. Dans de nombreuses situations réelles, nous ne savons pas à l'avance combien d'éléments nous devrons stocker. Dans la prochaine leçon, nous découvrirons une solution à ce problème avec la classe ArrayList, notre première incursion dans le puissant framework des Collections Java.