L’interface List en Java

Objectifs

• Comprendre ce qu'est une interface en Java.
• Expliquer le rôle et l'importance de l'interface List dans la Collection Framework.
• Apprendre à déclarer et initialiser des listes à l'aide de différentes implémentations (ArrayList, LinkedList, etc.).
• Comprendre les différences entre les implémentations de List.

Introduction :

• Une collection en Java est représentée comme un conteneur qui regroupe tous les éléments en une seule unité. Par exemple , un dossier de courrier (groupe d'e-mails), un annuaire téléphonique (mappage de noms sur des numéros de téléphone).
• L'API Collections propose un ensemble d'interfaces et de classes dont le but est de stocker de multiples objets. Elle propose quatre grandes familles de collections, chacune définie par une interface de base :
• List : collection d'éléments ordonnés qui accepte les doublons
• Set: collection d'éléments non ordonnés par défaut qui n'accepte pas les doublons
• Map: collection sous la forme d'une association de paires clé/valeur
• Queue et Deque: collections qui stockent des éléments dans un certain ordre avant qu'ils ne soient extraits pour traitement

L'interface List

• L’interface List en Java, qui fait partie de la bibliothèque standard, permet de stocker et de manipuler des éléments dans une liste ordonnée (éléments indexés).
• Pour comprendre cette interface, il est important de connaître quelques informations clés.
• List étend l'interface Collection et propose des méthodes spécifiques pour la manipulation de listes.
• Les éléments d’une liste sont ordonnés en fonction de leur position, et chaque élément peut être identifié par son index, c’est-à-dire sa position dans la liste.
• Les listes peuvent contenir des éléments en double, contrairement aux ensembles qui ne peuvent pas avoir de doublons. Certaines implémentations courantes de List comprennent ArrayList, LinkedList et Vector.

Les classes implémentant List

• En Java, l'interface List fait partie du framework des collections et représente une séquence ordonnée d'éléments.
• Une List permet de stocker des éléments en conservant leur ordre d'insertion, d'accéder aux éléments par leur index, et de gérer des éléments en doublon.
• Il est important de noter que List est une interface, ce qui signifie qu’elle ne peut pas être instanciée directement.
• Il faut utiliser une implémentation concrète comme ArrayList ou LinkedList pour créer une liste et manipuler ses éléments.
• Le framework propose des classes qui implémentent l'interface List : Vector, ArrayList, LinkedList et CopyOnWriteArrayList.
• Vous pouvez déclarer les différentes instances de la liste de la manière suivante :

  List linkedList = new LinkedList(); // LinkedList
  List arrayList = new ArrayList(); // ArrayList
  List vecList = new Vector(); // Vector
  List stackList = new Stack(); //Stack

• Plusieurs classes dans le JDK implémentent l'interface List, chacune ayant des caractéristiques uniques. Voici les principales classes qui implémentent List :

  1. ArrayList

     1. Description:

        • ArrayList est une implémentation de List basée sur un tableau dynamique. Elle permet un accès rapide (en temps constant) à un élément par son index, mais les opérations d'insertion et de suppression peuvent être lentes si elles nécessitent de déplacer beaucoup d'éléments.

     2. Caractéristiques:

        • Taille dynamique (s'ajuste automatiquement).
        • Accès rapide aux éléments par leur index.
        • Permet les éléments en doublon.
        • Non-synchronisée (non-thread-safe).

     3. Syntaxe de Java ArrayList

        • Avant la création d’un ArrayList, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util. import java.util.ArrayList;
        • La syntaxe générale est la suivante : ArrayList<Type> arrayList= new ArrayList<>();
        • "Type" correspond au type de données respectif de l'ArrayList Java.

        Les ArrayList utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "Integer" et non "int". ArrayList <String> arrayList= new ArrayList<>(); ArrayList <Integer> arrayList= new ArrayList<>();

     4. Exemple:

        • Avec la classe ArrayList, les opérations telles que l’ajout ou la suppression d’éléments ne sont pas exécutées avec des opérateurs Java, mais avec des méthodes prédéfinies.

        import java.util.ArrayList;
        import java.util.List;
        
        public class ExempleArrayList {
            public static void main(String[] args) {
                List<String> arrayList = new ArrayList<>();
                
                arrayList.add("Java");
                arrayList.add("Python");
                arrayList.add("C++");
                
                System.out.println("ArrayList: " + arrayList);
            }
        }

     5. Exercices:

        • Créer un programme Java qui permet de gérer une liste d'étudiants. Le programme doit permettre d'ajouter, de supprimer, de rechercher et d'afficher des étudiants dans une liste.
          • Demandez à l'utilisateur de saisir un nombre d'étudiants à ajouter.
          • Pour chaque étudiant, demandez à l'utilisateur de saisir le nom, puis ajoutez-le à la liste.
          • Affichez tous les étudiants présents dans la liste.
          • Demandez à l'utilisateur de saisir le nom d'un étudiant à rechercher dans la liste.
            • Si l'étudiant est trouvé, affichez un message indiquant que l'étudiant est présent dans la liste avec sa position (index).
            • Si l'étudiant n'est pas trouvé, indiquez qu'il n'est pas présent.
          • Demandez à l'utilisateur de saisir le nom d'un étudiant à supprimer de la liste.
            • Si l'étudiant est trouvé, supprimez-le de la liste et affichez un message confirmant la suppression.
            • Si l'étudiant n'est pas trouvé, indiquez qu'il n'est pas présent dans la liste.
          • Après les opérations de recherche et de suppression, affichez la liste finale des étudiants.
        Solution

        package listes;
        
        import java.util.ArrayList;
        import java.util.Scanner;
        
        public class activite_01 {
            public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                ArrayList<String> etudiants = new ArrayList<>();
        
                // Demander le nombre d'étudiants à ajouter
                System.out.print("Combien d'étudiants voulez-vous ajouter ? ");
                int nombreEtudiants = scanner.nextInt();
                scanner.nextLine(); // Consommer le retour à la ligne
        
                // Ajouter les étudiants à la liste
                for (int i = 0; i < nombreEtudiants; i++) {
                    System.out.print("Entrez le nom de l'étudiant " + (i + 1) + " : ");
                    String nom = scanner.nextLine();
                    etudiants.add(nom);
                }
        
                // Afficher la liste des étudiants
                System.out.println("\nListe des étudiants : " + etudiants);
        
                // Rechercher un étudiant dans la liste
                System.out.print("\nEntrez le nom de l'étudiant à rechercher : ");
                String nomRecherche = scanner.nextLine();
                if (etudiants.contains(nomRecherche)) {
                    System.out.println(nomRecherche + " est présent dans la liste à l'index " + etudiants.indexOf(nomRecherche));
                } else {
                    System.out.println(nomRecherche + " n'est pas présent dans la liste.");
                }
        
                // Supprimer un étudiant de la liste
                System.out.print("\nEntrez le nom de l'étudiant à supprimer : ");
                String nomSuppression = scanner.nextLine();
                if (etudiants.remove(nomSuppression)) {
                    System.out.println(nomSuppression + " a été supprimé de la liste.");
                } else {
                    System.out.println(nomSuppression + " n'est pas présent dans la liste.");
                }
        
                // Afficher la liste finale des étudiants
                System.out.println("\nListe finale des étudiants : " + etudiants);
        
                scanner.close();
            }
        }
        

  2. LinkedList

     1. Description:

        • LinkedList est une implémentation de List basée sur une liste chaînée doubly linked (chaînée dans les deux sens). Cela rend l'insertion et la suppression d'éléments au début ou au milieu de la liste plus efficaces par rapport à ArrayList, mais l'accès par index est plus lent.

     2. Caractéristiques:

        • Insertion/suppression rapide au début/milieu de la liste.
        • Accès par index plus lent que ArrayList.
        • Peut être utilisée comme une Deque (double-ended queue) grâce à ses méthodes spécifiques.
        • Permet les éléments en doublon.
        • Non-synchronisée (non-thread-safe).

     3. Syntaxe de Java LinkedList

        • Avant la création d’une LinkedList, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util. import java.util.LinkedList;
        • La syntaxe générale est la suivante : LinkedList<Type> linkedList = new LinkedList<>();
        • "Type" correspond au type de données respectif de la LinkedList Java.

        Les LinkedList utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "Integer" et non "int".
        LinkedList <String> linkedList = new LinkedList<>();
LinkedList <Integer> linkedList = new LinkedList<>();

     4. Exemple:

        import java.util.LinkedList;
        import java.util.List;
        
        public class ExempleLinkedList {
            public static void main(String[] args) {
                List<String> linkedList = new LinkedList<>();
                
                linkedList.add("Java");
                linkedList.add("Python");
                linkedList.add("C++");
                
                System.out.println("LinkedList: " + linkedList);
            }
        }

     5. Exercice:

        • Créer un programme Java qui permet de gérer une liste d'étudiants en utilisant une LinkedList. Le programme doit permettre d'ajouter, de supprimer, de rechercher et d'afficher des étudiants dans cette liste.
          • Demandez à l'utilisateur de saisir un nombre d'étudiants à ajouter.
          • Pour chaque étudiant, demandez à l'utilisateur de saisir le nom, puis ajoutez-le à la LinkedList.
          • Affichez tous les étudiants présents dans la LinkedList.
          • Demandez à l'utilisateur de saisir le nom d'un étudiant à rechercher dans la LinkedList.
            • Si l'étudiant est trouvé, affichez un message indiquant que l'étudiant est présent dans la liste avec sa position (index).
            • Si l'étudiant n'est pas trouvé, indiquez qu'il n'est pas présent dans la liste.
          • Demandez à l'utilisateur de saisir le nom d'un étudiant à supprimer de la LinkedList.
            • Si l'étudiant est trouvé, supprimez-le de la liste et affichez un message confirmant la suppression.
            • Si l'étudiant n'est pas trouvé, indiquez qu'il n'est pas présent dans la liste.
          • Après les opérations de recherche et de suppression, affichez la liste finale des étudiants.
        Solution

        import java.util.LinkedList;
        import java.util.Scanner;
        
        public class GestionEtudiants {
            public static void main(String[] args) {
                // Création de la LinkedList pour stocker les noms des étudiants
                LinkedList<String> etudiants = new LinkedList<>();
                Scanner scanner = new Scanner(System.in);
        
                // Demande à l'utilisateur le nombre d'étudiants à ajouter
                System.out.print("Combien d'étudiants souhaitez-vous ajouter ? ");
                int nombreEtudiants = scanner.nextInt();
                scanner.nextLine(); // Consomme la nouvelle ligne après l'entier
        
                // Ajout des étudiants dans la LinkedList
                for (int i = 0; i < nombreEtudiants; i++) {
                    System.out.print("Entrez le nom de l'étudiant " + (i + 1) + " : ");
                    String nom = scanner.nextLine();
                    etudiants.add(nom);
                }
        
                // Affichage des étudiants dans la LinkedList
                System.out.println("Liste des étudiants : " + etudiants);
        
                // Recherche d'un étudiant dans la LinkedList
                System.out.print("Entrez le nom de l'étudiant à rechercher : ");
                String rechercheNom = scanner.nextLine();
                int indexRecherche = etudiants.indexOf(rechercheNom);
                if (indexRecherche != -1) {
                    System.out.println(rechercheNom + " est présent dans la liste à l'indice " + indexRecherche);
                } else {
                    System.out.println(rechercheNom + " n'est pas présent dans la liste.");
                }
        
                // Suppression d'un étudiant de la LinkedList
                System.out.print("Entrez le nom de l'étudiant à supprimer : ");
                String supprimerNom = scanner.nextLine();
                if (etudiants.remove(supprimerNom)) {
                    System.out.println(supprimerNom + " a été supprimé de la liste.");
                } else {
                    System.out.println(supprimerNom + " n'est pas présent dans la liste.");
                }
        
                // Affichage de la liste finale des étudiants
                System.out.println("Liste finale des étudiants : " + etudiants);
            }
        }
        

  3. Vector

     1. Description:

        • Vector est similaire à ArrayList, mais il est synchronisé, ce qui signifie qu'il est thread-safe (c'est-à-dire qu'il peut être utilisé dans des contextes où plusieurs threads accèdent à la liste simultanément). Cependant, cette synchronisation rend Vector moins performant que ArrayList en termes de vitesse.

     2. Caractéristiques:

        • Synchronisé (thread-safe).
        • Taille dynamique (s'ajuste automatiquement).
        • Accès rapide aux éléments par leur index.
        • Permet les éléments en doublon.

     3. Syntaxe de Java Vector

        • Avant la création d’un `Vector`, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util. import java.util.Vector;
        • La syntaxe générale est la suivante : Vector<Type> vector = new Vector<>();
        • "Type" correspond au type de données respectif de l'Vector Java.

        Les `Vector` utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "Integer" et non "int". Vector<String> vector = new Vector<>(); Vector<Integer> vector = new Vector<>();

     4. Exemple:

        import java.util.List;
        import java.util.Vector;
        
        public class ExempleVector {
            public static void main(String[] args) {
                List<String> vector = new Vector<>();
                
                vector.add("Java");
                vector.add("Python");
                vector.add("C++");
                
                System.out.println("Vector: " + vector);
            }
        }

  4. Stack

     1. Description:

        • Stack est une sous-classe de Vector qui représente une pile (LIFO - Last In, First Out). Les éléments sont ajoutés et retirés du haut de la pile.

     2. Caractéristiques:

        • Hérite de Vector, donc thread-safe.
        • Suit le principe LIFO (Last In, First Out).
        • Permet les éléments en doublon.

     3. Syntaxe de Java Stack

        • Avant la création d’une `Stack`, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util. import java.util.Stack;
        • La syntaxe générale est la suivante : Stack<Type> stack = new Stack<>();
        • "Type" correspond au type de données respectif de la Stack Java.

        Les `Stack` utilisent les classes enveloppes correspondantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir "Integer" et non "int". Stack<String> stack = new Stack<>(); Stack<Integer> stack = new Stack<>();

     4. Exemple:

        import java.util.Stack;
        
        public class ExempleStack {
            public static void main(String[] args) {
                Stack<String> stack = new Stack<>();
                
                stack.push("Java");
                stack.push("Python");
                stack.push("C++");
                
                System.out.println("Stack avant pop: " + stack);
                
                stack.pop();
                
                System.out.println("Stack après pop: " + stack);
            }
        }

Les principales différences entre ces collections Java

Caractéristique	ArrayList	LinkedList	Vector	Stack
Structure interne	Tableau dynamique	Liste doublement chaînée	Tableau dynamique	Hérite de Vector, basé sur un tableau dynamique
Accès aux éléments	Rapide (O(1))	Plus lent (O(n))	Rapide (O(1))	Accès LIFO (Last In, First Out)
Insertion/Suppression	Lent au milieu ou au début (O(n))	Efficace aux extrémités (O(1))	Lent au milieu ou au début (O(n))	Utilise push, pop, peek (LIFO)
Synchronisation	Non synchronisé, pas thread-safe	Non synchronisé, pas thread-safe	Synchronisé, thread-safe	Synchronisé, car hérite de Vector
Utilisation principale	Accès rapide, opérations de recherche fréquentes	Insertion/suppression fréquentes aux extrémités	Besoin de thread-safety sans synchronisation manuelle	Scénarios nécessitant une structure de pile (LIFO)

Méthodes de l’interface List

• Voici quelques-unes des méthodes les plus couramment utilisées de l'interface List :

  1. int size(): Détermine le nombre d'éléments dans une liste.

     import java.util.ArrayList;
     import java.util.List;
     
     public class ExampleSize {
         public static void main(String[] args) {
             // Créer une liste de chaînes de caractères
             List<String> fruits = new ArrayList<>();
     
             // Ajouter des éléments à la liste
             fruits.add("Apple");
             fruits.add("Banana");
             fruits.add("Orange");
     
             // Utiliser la méthode size() pour obtenir le nombre d'éléments dans la liste
             int numberOfFruits = fruits.size();
     
             // Afficher le nombre d'éléments dans la liste
             System.out.println("The number of fruits in the list is: " + numberOfFruits);
         }
     }
     

  2. boolean isEmpty(): Vérifie si la liste est vide.

     import java.util.ArrayList;
     import java.util.List;
     
     public class ExampleIsEmpty {
         public static void main(String[] args) {
             // Créer une liste de chaînes de caractères
             List<String> fruits = new ArrayList<>();
     
             // Vérifier si la liste est vide
             if (fruits.isEmpty()) {
                 System.out.println("The list is empty.");
             } else {
                 System.out.println("The list is not empty.");
             }
     
             // Ajouter un élément à la liste
             fruits.add("Apple");
     
             // Vérifier à nouveau si la liste est vide
             if (fruits.isEmpty()) {
                 System.out.println("The list is empty.");
             } else {
                 System.out.println("The list is not empty.");
             }
         }
     }
     

  3. boolean contains(Object o): Retourne true si l'objet spécifié est présent dans la liste.

     import java.util.ArrayList;
     import java.util.List;
     
     public class ExampleContains {
         public static void main(String[] args) {
             // Créer une liste de chaînes de caractères
             List<String> fruits = new ArrayList<>();
     
             // Ajouter des éléments à la liste
             fruits.add("Apple");
             fruits.add("Banana");
             fruits.add("Orange");
     
             // Vérifier si la liste contient "Banana"
             if (fruits.contains("Banana")) {
                 System.out.println("The list contains Banana.");
             } else {
                 System.out.println("The list does not contain Banana.");
             }
     
             // Vérifier si la liste contient "Grapes"
             if (fruits.contains("Grapes")) {
                 System.out.println("The list contains Grapes.");
             } else {
                 System.out.println("The list does not contain Grapes.");
             }
         }
     }
     

  4. add(E element): ajoute un élément à la fin de la liste.

     import java.util.List;
     import java.util.ArrayList;
     
     public class ListExample {
         public static void main(String[] args) {
             List<String> list = new ArrayList<>();
             list.add("Apple");
             list.add("Banana");
             list.add("Cherry");
             System.out.println("Liste après ajout des éléments : " + list);
         }
     }

  5. add(int index, E element): insère un élément à une position donnée dans la liste.

     import java.util.List;
     import java.util.ArrayList;
     
     public class ListExample {
         public static void main(String[] args) {
             List<String> list = new ArrayList<>();
             list.add("Apple");
             list.add("Cherry");
             list.add(1, "Banana"); // Insère "Banana" à l'indice 1
             System.out.println("Liste après insertion d'un élément à l'indice 1 : " + list);
         }
     }

  6. remove(int index): supprime l’élément à la position donnée dans la liste.

     import java.util.List;
     import java.util.ArrayList;
     
     public class ListExample {
         public static void main(String[] args) {
             List<String> list = new ArrayList<>();
             list.add("Apple");
             list.add("Banana");
             list.add("Cherry");
             list.remove(1); // Supprime l'élément à l'indice 1
             System.out.println("Liste après suppression de l'élément à l'indice 1 : " + list);
         }
     }

  7. get(int index): récupère l’élément à la position donnée dans la liste.

     import java.util.List;
     import java.util.ArrayList;
     
     public class ListExample {
         public static void main(String[] args) {
             List<String> list = new ArrayList<>();
             list.add("Apple");
             list.add("Banana");
             list.add("Cherry");
             String element = list.get(1); // Récupère l'élément à l'indice 1
             System.out.println("Élément à l'indice 1 : " + element);
         }
     }
     

  8. set(int index, E element) : remplace l’élément à la position donnée dans la liste par un nouvel élément.

     import java.util.List;
     import java.util.ArrayList;
     
     public class ListExample {
         public static void main(String[] args) {
             List<String> list = new ArrayList<>();
             list.add("Apple");
             list.add("Banana");
             list.add("Cherry");
             list.set(1, "Blueberry"); // Remplace l'élément à l'indice 1 par "Blueberry"
             System.out.println("Liste après modification de l'élément à l'indice 1 : " + list);
         }
     }
     

Conclusion

• Chacune des classes qui implémentent List a ses propres avantages et inconvénients, en fonction du contexte d'utilisation :
• ArrayList est idéale pour les scénarios où l'accès rapide par index est crucial.
• LinkedList est préférable pour les applications nécessitant des insertions ou suppressions fréquentes.
• Vector et Stack sont utilisés lorsque la synchronisation (thread safety) est nécessaire.

Exercices d'application

1. Exercice 1 : Manipulation de ArrayList

   • Créez une ArrayList de chaînes de caractères pour stocker les noms des jours de la semaine. Utilisez différentes méthodes de l'interface List pour manipuler la liste.
     • Créez une ArrayList<String>.
     • Ajoutez les noms des jours de la semaine ("Lundi", "Mardi", etc.) à la liste.
     • Insérez un jour supplémentaire au milieu de la liste.
     • Remplacez un jour par un autre.
     • Affichez le nombre total de jours dans la liste.
     • Supprimez un jour spécifique de la liste.
     • Affichez la liste complète.
     Solution

     
     import java.util.ArrayList;
     import java.util.List;
     
     public class Exercice1 {
         public static void main(String[] args) {
             List<String> jours = new ArrayList<>();
             
             // Ajout des jours de la semaine
             jours.add("Lundi");
             jours.add("Mardi");
             jours.add("Mercredi");
             jours.add("Jeudi");
             jours.add("Vendredi");
             jours.add("Samedi");
             jours.add("Dimanche");
             
             // Insertion d'un jour supplémentaire
             jours.add(3, "Jour Supplémentaire");
             
             // Remplacement d'un jour
             jours.set(1, "Nouveau Mardi");
             
             // Affichage du nombre total de jours
             System.out.println("Nombre total de jours : " + jours.size());
             
             // Suppression d'un jour
             jours.remove("Vendredi");
             
             // Affichage de la liste complète
             System.out.println("Liste des jours : " + jours);
         }
     }

2. Exercice 2 : Recherche et tri

   • Description: Créez une liste d'entiers et effectuez des opérations de recherche et de tri.
     • Créez une ArrayList<Integer> et ajoutez plusieurs nombres aléatoires.
     • Recherchez un nombre spécifique dans la liste et affichez son index.
     • Triez la liste par ordre croissant.
     • Affichez la liste triée.
     • Recherchez le plus grand et le plus petit nombre de la liste.
     Solution

     
     import java.util.ArrayList;
     import java.util.Collections;
     import java.util.List;
     
     public class Exercice2 {
         public static void main(String[] args) {
             List nombres = new ArrayList<>();
             
             // Ajout de nombres aléatoires
             nombres.add(42);
             nombres.add(15);
             nombres.add(89);
             nombres.add(3);
             nombres.add(58);
             
             // Recherche d'un nombre spécifique
             int index = nombres.indexOf(89);
             System.out.println("L'index du nombre 89 est : " + index);
             
             // Tri de la liste
             Collections.sort(nombres);
             
             // Affichage de la liste triée
             System.out.println("Liste triée : " + nombres);
             
             // Recherche du plus grand et du plus petit nombre
             int max = Collections.max(nombres);
             int min = Collections.min(nombres);
             
             System.out.println("Le plus grand nombre est : " + max);
             System.out.println("Le plus petit nombre est : " + min);
         }
     }

3. Exercice 3 : Liste de listes (List<List<String>>)

   • Description : Créez une liste qui contient d'autres listes de chaînes de caractères.
     • Créez une ArrayList pour représenter chaque classe d'une école (par exemple, "Classe 1", "Classe 2").
     • Dans chaque classe, ajoutez des noms d'étudiants.
     • Ajoutez chaque liste de classe à une liste principale.
     • Parcourez et affichez les étudiants de chaque classe.
     Solution

     import java.util.ArrayList;
     import java.util.List;
     
     public class Exercice3 {
         public static void main(String[] args) {
             List<List<String>> ecole = new ArrayList<>();
             
             // Classe 1
             List<String> classe1 = new ArrayList<>();
             classe1.add("Alice");
             classe1.add("Bob");
             
             // Classe 2
             List<String> classe2 = new ArrayList<>();
             classe2.add("Charlie");
             classe2.add("David");
             
             // Ajout des classes à la liste principale
             ecole.add(classe1);
             ecole.add(classe2);
             
             // Affichage des étudiants par classe
             for (int i = 0; i < ecole.size(); i++) {
                 System.out.println("Classe " + (i + 1) + " : " + ecole.get(i));
             }
         }
     }

4. Exercice 4 : Manipulation avec LinkedList

   • Description : Travaillez avec une LinkedList pour manipuler une liste de tâches à faire.
     • Créez une LinkedList<String> pour stocker des tâches à faire.
     • Ajoutez des tâches à la fin de la liste.
     • Ajoutez une tâche au début de la liste.
     • Supprimez la première et la dernière tâche de la liste.
     • Affichez la liste complète.
     Solution

     import java.util.LinkedList;
     import java.util.List;
     
     public class Exercice4 {
         public static void main(String[] args) {
             List<String> toDoList = new LinkedList<>();
             
             // Ajout de tâches
             toDoList.add("Faire les courses");
             toDoList.add("Étudier le Java");
             toDoList.add("Faire du sport");
             
             // Ajout d'une tâche au début de la liste
             ((LinkedList<String>) toDoList).addFirst("Se réveiller tôt");
             
             // Suppression de la première et dernière tâche
             ((LinkedList<String>) toDoList).removeFirst();
             ((LinkedList<String>) toDoList).removeLast();
             
             // Affichage de la liste complète
             System.out.println("Liste des tâches : " + toDoList);
         }
     }

5. Exercice 5 : Utilisation de List avec des objets

   • Description : Créez une liste pour gérer une collection d'objets personnalisés.
     • Créez une classe Produit avec des attributs comme nom et prix.
     • Créez une ArrayList<Produit> pour stocker plusieurs objets Produit.
     • Ajoutez plusieurs produits à la liste.
     • Affichez tous les produits dans la liste.
     • Modifiez le prix d'un produit spécifique dans la liste.
     • Supprimez un produit de la liste par son nom.
     Solution

     import java.util.ArrayList;
     import java.util.List;
     
     class Produit {
         String nom;
         double prix;
     
         Produit(String nom, double prix) {
             this.nom = nom;
             this.prix = prix;
         }
     
         @Override
         public String toString() {
             return nom + " - " + prix + " €";
         }
     }
     
     public class Exercice5 {
         public static void main(String[] args) {
             List produits = new ArrayList<>();
             
             // Ajout de produits
             produits.add(new Produit("Ordinateur", 800.0));
             produits.add(new Produit("Téléphone", 500.0));
             produits.add(new Produit("Tablette", 300.0));
             
             // Affichage des produits
             System.out.println("Produits disponibles : " + produits);
             
             // Modification du prix d'un produit
             for (Produit p : produits) {
                 if (p.nom.equals("Téléphone")) {
                     p.prix = 450.0;
                 }
             }
             
             // Suppression d'un produit par son nom
             produits.removeIf(p -> p.nom.equals("Tablette"));
             
             // Affichage des produits après modification
             System.out.println("Produits après modification : " + produits);
         }
     }