Gestion de listes dynamiques avec ArrayList

1. Des tableaux fixes aux listes dynamiques

La principale faiblesse d'un tableau classique (String[], int[], etc.) est que sa taille est définie une fois pour toutes. Si vous déclarez un tableau de 10 éléments et que vous avez besoin d'en stocker un onzième, vous êtes bloqué. ArrayList a été conçu pour résoudre précisément ce problème.

Regardez le début de cette vidéo qui illustre parfaitement le passage du tableau statique à l'ArrayList.

Un ArrayList est une classe qui implémente l'interface List. Pensez-y comme à un "tableau amélioré" qui présente les caractéristiques suivantes :

• Taille dynamique : Il grandit et rétrécit automatiquement pour s'adapter au nombre d'éléments.
• Ordonnée : Il conserve l'ordre dans lequel les éléments sont insérés.
• Autorise les doublons : Vous pouvez y stocker plusieurs fois le même élément.

2. Déclaration et utilisation des génériques

Pour créer un ArrayList, vous devez importer la classe depuis java.util et utiliser une syntaxe spécifique qui introduit un concept crucial en Java : les génériques (generics).

Les génériques, représentés par des chevrons (< >), permettent de spécifier le type de données que votre liste contiendra. C'est une mesure de sécurité essentielle qui empêche de mélanger différents types de données par erreur.

// Importation nécessaire au début de votre fichier
import java.util.ArrayList; 
import java.util.List; // Bonne pratique d'importer l'interface aussi

public class Main {
    public static void main(String[] args) {
        // Déclaration d'un ArrayList qui ne contiendra que des chaînes de caractères (String)
        ArrayList<String> noms = new ArrayList<>();

        // Déclaration en utilisant l'interface List (meilleure pratique)
        // Cela rend votre code plus flexible si vous décidez de changer pour une autre implémentation de List plus tard
        List<Integer> notes = new ArrayList<>();
    }
}

Bonne pratique : Depuis Java 7, vous pouvez utiliser l'opérateur "diamant" (<>) dans la partie droite de l'initialisation. Le compilateur déduit le type à partir de la déclaration, ce qui allège le code. C'est la syntaxe que vous devriez toujours utiliser.

3. Les opérations fondamentales (CRUD)

Comme pour toute structure de données, vous devez savoir comment créer, lire, mettre à jour et supprimer des éléments (CRUD : Create, Read, Update, Delete). ArrayList fournit des méthodes très intuitives pour cela.

La vidéo suivante vous montrera en action les méthodes les plus courantes.

Pour une référence textuelle complète que vous pourrez consulter plus tard, l'article suivant est excellent.

Voici un tableau récapitulatif des méthodes essentielles :

4. Sous le capot : le redimensionnement automatique

Comment ArrayList réussit-il à être "dynamique" ? Votre expérience en développement vous amène sûrement à vous poser cette question. La réponse est que, en interne, il utilise un tableau classique. Lorsque ce tableau interne est plein, ArrayList en crée un nouveau, plus grand, et y copie tous les anciens éléments avant d'ajouter le nouvel élément.

Ce processus est efficace mais a un coût en performance. Si vous savez à l'avance que vous allez stocker un grand nombre d'éléments, vous pouvez optimiser en spécifiant une capacité initiale lors de la création de la liste. Cela permet d'éviter de multiples opérations de redimensionnement coûteuses.

// Crée une ArrayList avec une capacité initiale de 1000 éléments.
// Aucune opération de redimensionnement ne sera faite avant le 1001ème ajout.
List<String> utilisateurs = new ArrayList<>(1000); 

5. Utiliser ArrayList avec vos propres objets

Jusqu'à présent, nous avons utilisé des types simples comme String ou Integer. Mais la véritable puissance de ArrayList se révèle lorsque vous l'utilisez avec vos propres classes, comme Utilisateur, Produit ou Commande.

class Produit {
    private String nom;
    private double prix;

    public Produit(String nom, double prix) {
        this.nom = nom;
        this.prix = prix;
    }

    // ... getters et setters ...
}

List<Produit> catalogue = new ArrayList<>();
catalogue.add(new Produit("Laptop Pro", 1499.99));
catalogue.add(new Produit("Souris Gamer", 79.50));

Lorsque vous faites cela, il y a deux méthodes que vous devez impérativement redéfinir (@Override) dans votre classe (Produit dans cet exemple) pour que les collections se comportent correctement.

1. toString() : Pour un affichage lisible. Si vous ne la redéfinissez pas, un System.out.println(catalogue) affichera une liste de références mémoire peu utiles (ex: [Produit@1b6d3586, Produit@4554617c]).
2. equals() et hashCode() : Pour la recherche et la comparaison. Des méthodes comme contains() et remove(objet) utilisent equals() pour trouver l'objet dans la liste. Sans une redéfinition correcte, Java compare les références mémoire, pas le contenu des objets. Deux objets Produit avec le même nom et le même prix ne seront pas considérés comme égaux !

La ressource suivante explique ce point crucial avec un excellent exemple.

6. Exercice pratique : Gestionnaire de tâches

Mettons tout cela en pratique. Vous allez créer un petit gestionnaire de tâches.

Énoncé :

1. Créez une classe Tache avec les attributs description (String) et estTerminee (boolean).
2. Dans la classe Tache, redéfinissez :
   • Le constructeur pour initialiser une tâche avec sa description (par défaut, estTerminee sera false).
   • toString() pour afficher la tâche de manière claire (par ex: [X] Faire les courses ou [ ] Apprendre Java).
   • equals() et hashCode() basés sur la description pour que deux tâches avec la même description soient considérées comme identiques. Votre IDE (IntelliJ ou VS Code) peut générer ces méthodes pour vous.
3. Créez une classe principale GestionnaireTaches avec une méthode main.
4. Dans le main, créez une ArrayList<Tache> nommée taches.
5. Ajoutez-y 3 ou 4 tâches.
6. Affichez toutes les tâches en utilisant une boucle for-each.
7. "Terminez" une des tâches en y accédant via son index (get()) et en appelant un setter pour modifier son statut.
8. Affichez de nouveau toutes les tâches pour voir le changement.
9. Vérifiez si une tâche spécifique existe en utilisant contains() sur un nouvel objet Tache.
10. Supprimez une des tâches par son index ou sa valeur et affichez la liste finale.

import java.util.Objects;

public class Tache {
    private String description;
    private boolean estTerminee;

    public Tache(String description) {
        this.description = description;
        this.estTerminee = false;
    }

    public String getDescription() {
        return description;
    }

    public boolean isEstTerminee() {
        return estTerminee;
    }

    public void setEstTerminee(boolean estTerminee) {
        this.estTerminee = estTerminee;
    }

    @Override
    public String toString() {
        return (estTerminee ? "[X] " : "[ ] ") + description;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tache tache = (Tache) o;
        return Objects.equals(description, tache.description);
    }

    @Override
    public int hashCode() {
        return Objects.hash(description);
    }
}

import java.util.ArrayList;
import java.util.List;

public class GestionnaireTaches {
    public static void main(String[] args) {
        List<Tache> taches = new ArrayList<>();

        // Ajout de tâches
        taches.add(new Tache("Apprendre les ArrayLists en Java"));
        taches.add(new Tache("Faire l'exercice pratique"));
        taches.add(new Tache("Préparer la réunion de demain"));
        taches.add(new Tache("Acheter du café"));

        System.out.println("--- Liste de tâches initiale ---");
        for (Tache tache : taches) {
            System.out.println(tache);
        }

        // Marquer une tâche comme terminée
        System.out.println("\n> On termine la deuxième tâche...");
        taches.get(1).setEstTerminee(true);

        System.out.println("\n--- Liste de tâches mise à jour ---");
        for (Tache tache : taches) {
            System.out.println(tache);
        }

        // Vérifier l'existence d'une tâche
        Tache recherche = new Tache("Acheter du café");
        System.out.println("\n> La liste contient-elle la tâche 'Acheter du café' ? " + taches.contains(recherche));

        // Supprimer une tâche
        System.out.println("\n> On supprime la tâche à l'index 0...");
        taches.remove(0);

        System.out.println("\n--- Liste de tâches finale ---");
        for (Tache tache : taches) {
            System.out.println(tache);
        }
        
        System.out.println("\nNombre final de tâches : " + taches.size());
    }
}

Conclusion

Aujourd'hui, vous avez ajouté une structure de données fondamentale et extrêmement polyvalente à votre boîte à outils Java. ArrayList sera votre choix par défaut dans de très nombreuses situations.

Points clés à retenir :

• ArrayList est une liste dynamique et ordonnée qui résout le problème de taille fixe des tableaux.
• L'utilisation des génériques (ArrayList<Type>) est non négociable pour garantir la sécurité de votre code.
• Les méthodes de base (add, get, set, remove, size) sont simples et puissantes.
• Le redimensionnement automatique a un coût en performance ; l'utilisation d'une capacité initiale peut être une optimisation judicieuse.
• Pour utiliser ArrayList avec vos propres classes, vous devez redéfinir toString(), equals() et hashCode() pour un comportement correct.

Dans les prochaines leçons, nous continuerons notre exploration du Framework des Collections. Nous découvrirons HashMap, pour stocker des paires clé-valeur, et HashSet, pour garantir l'unicité des éléments. Vous apprendrez ainsi à choisir la structure de données la plus adaptée à chaque problème.