Correction TP Généricité Collection

Ce TP porte sur la généricité en Java appliquée aux collections et structures de données. Il propose plusieurs exercices permettant de comprendre et d'implémenter des piles génériques en représentation chaînée, avec des tableaux dynamiques (ArrayList) et des listes chaînées (LinkedList). Il aborde également la conception d'une architecture de tâches génériques et la gestion d'un annuaire avec une table de hachage. Pour réaliser ce TP, il est nécessaire de maîtriser les bases de la programmation Java, notamment les génériques, les collections et les interfaces.

Objectifs

• Comprendre et implémenter une pile générique en représentation chaînée.
• Utiliser les collections génériques Java telles que ArrayList et LinkedList pour gérer des piles.
• Concevoir une architecture de tâches composées avec des sous-tâches et calculer leur coût total.
• Manipuler une table de hachage (HashMap) pour gérer un annuaire de contacts.
• Appliquer les concepts de généricité pour rendre les structures de données réutilisables et sûres.

Prérequis et installation

• Environnement Java (JDK) installé, version compatible avec les génériques (Java 5 ou supérieur).
• Connaissance des concepts de programmation orientée objet en Java.
• Notions sur les interfaces, classes génériques, collections Java (ArrayList, LinkedList, HashMap).
• Un IDE ou un éditeur de texte pour écrire et compiler les fichiers Java.

Exercice 1 : Pile générique en représentation chaînée

Dans cet exercice, vous allez implémenter une pile générique utilisant une représentation chaînée via une classe Noeud. L'interface PileGen définit les opérations classiques d'une pile : vérifier si elle est vide, accéder au dernier élément, empiler et dépiler.

La classe PileListe<T> implémente cette interface avec un champ sommet de type Noeud<T> représentant le sommet de la pile.

Procédure :

1. Déclarez l'interface PileGen<T> avec les méthodes estVide(), dernier(), depiler() et empiler(T o).
2. Créez la classe Noeud<T> contenant un champ info de type T et un champ suivant de type Noeud<T>.
3. Implémentez la classe PileListe<T> avec :
• Un constructeur initialisant sommet à null.
• La méthode estVide() qui retourne true si sommet est null.
• La méthode dernier() qui retourne l'information du sommet.
• La méthode empiler(T o) qui crée un nouveau noeud, le place en sommet et lie l'ancien sommet en suivant.
• La méthode depiler() qui fait pointer sommet vers le noeud suivant.
4. Testez la pile dans la classe TestPile en empilant les entiers de 0 à 9, puis en dépilant et affichant chaque élément.

Un résultat correct affiche les entiers de 9 à 0 dans l'ordre décroissant lors du dépilage.

Exercice 2 : Pile et collection générique avec ArrayList

Ce TP propose deux versions de pile : une non générique basée sur un tableau d'entiers, et une générique utilisant ArrayList.

Procédure :

1. La classe PileTab implémente une pile d'entiers avec un tableau fixe de taille 4 et un index pos indiquant la position du sommet.
• La méthode add(int e) ajoute un entier si la pile n'est pas pleine, sinon affiche un message d'erreur.
• La méthode remove() dépile l'élément au sommet et le retourne.
• Les méthodes estVide(), size(), affiche() et getSommet() permettent respectivement de vérifier si la pile est vide, obtenir sa taille, afficher tous les éléments et accéder au sommet.
2. La classe générique TruePileGen<T> utilise une ArrayList<T> pour stocker les éléments.
• Les méthodes add(T e), remove(), estVide(), size(), affiche() et getSommet() sont similaires à celles de PileTab, adaptées à la collection générique.
• L'affichage utilise un itérateur pour parcourir la liste.
3. Dans la classe Test, testez :
• La pile non générique PileTab en ajoutant des entiers et en affichant les opérations d'empilement et dépilement.
• La pile générique TruePileGen<Point> en ajoutant des objets Point (coordonnées x,y), en affichant la pile, en dépilant un élément et en affichant le sommet.

Un résultat correct affiche les points dans l'ordre d'empilement, puis après dépilage, le sommet mis à jour.

Exercice 3 : Pile et collection générique avec LinkedList

Cette partie utilise l'interface IPile<A> et la classe CPile<A> qui implémente une pile générique basée sur une LinkedList<A>.

Procédure :

1. Définissez l'interface IPile<A> avec les méthodes :
• estVide()
• empile(A a)
• depile() : dépile et retourne l'élément au sommet
• nbElements()
• sommet() : retourne le sommet sans dépiler

Implémentez la classe CPile<A> avec un champ LinkedList<A> l :

• Le constructeur initialise la liste.
• empile(A a) ajoute en tête avec addFirst(a).
• depile() supprime et retourne le premier élément avec removeFirst().
• sommet() retourne l'élément en tête avec peek().

Testez dans la classe Test en empilant les entiers 1, 2, 3, puis en affichant le sommet et en dépilant tous les éléments.

Un résultat correct affiche successivement le sommet (3), puis les éléments dépilés dans l'ordre 3, 2, 1.

Exercice 4 : Compréhension de l’architecture des tâches

Ce TP propose une modélisation de tâches élémentaires et complexes, avec calcul du coût total.

Procédure :

1. Définissez l'interface Tache avec :
• String getNom()
• int getCout()
2. Implémentez la classe TacheElementaire avec un nom et un coût, et les méthodes d'accès correspondantes.
3. Implémentez la classe TacheComplexe qui contient une liste de sous-tâches (ArrayList<Tache>) :
• Un constructeur initialisant la liste et le nom.
• Les méthodes ajouter(Tache t) et supprimer(Tache t) pour gérer les sous-tâches.
• La méthode getCout() qui somme les coûts des sous-tâches.
4. Dans la classe Test, créez une tâche complexe, ajoutez des tâches élémentaires, affichez le coût total, puis créez une seconde tâche complexe contenant la première et ajoutez une nouvelle tâche élémentaire.
5. Affichez les coûts des tâches complexes pour vérifier la composition.

Un résultat correct affiche les coûts cumulés des tâches complexes selon les sous-tâches ajoutées.

Exercice : Annuaire

Ce TP illustre la gestion d'un annuaire de contacts avec une table de hachage (HashMap).

Procédure :

1. Créez la classe Fiche avec les champs :
• int numero
• String nom
• String adresse
2. Implémentez plusieurs constructeurs :
• Un constructeur complet avec nom, numéro et adresse.
• Un constructeur avec seulement le nom, les autres champs initialisés par défaut (numéro à -1, adresse à null).
3. Créez la classe Annuaire avec un champ Map<String,Fiche> contacts initialisé en HashMap.
4. Implémentez les méthodes :
• getNbcontacts() : retourne la taille de la map.
• addContact(Fiche f) : ajoute une fiche dans la map avec la clé nom.
• addContact(String s, int n, String a) : ajoute un contact avec nom, numéro et adresse.
• addContact(String s) : ajoute un contact avec nom seul.
• getnumero(String name) : recherche le numéro associé à un nom, en ignorant la casse. Retourne -1 si non trouvé.
• affiche() : affiche tous les contacts avec leur numéro et adresse.
5. Dans le test, créez un annuaire, ajoutez plusieurs contacts, affichez le nombre de contacts, affichez tous les contacts, puis récupérez et affichez le numéro d'un contact avec un nom en casse différente.

Un résultat correct affiche le nombre de contacts, la liste complète, et le numéro correct même si la casse du nom diffère.

Résultats attendus

• Exercice 1 : Affichage des entiers de 9 à 0 lors du dépilage.
• Exercice 2 : Affichage des éléments empilés et dépilés correctement pour les piles non générique et générique (ArrayList), avec les points affichés dans l'ordre d'empilement.
• Exercice 3 : Affichage du sommet (3) puis dépilage des éléments 3, 2, 1 dans l'ordre.
• Exercice 4 : Affichage des coûts cumulés des tâches complexes, par exemple 60 pour la première tâche complexe et 100 pour la seconde selon les sous-tâches ajoutées.
• Annuaire : Affichage du nombre de contacts, liste complète avec numéro et adresse, et récupération correcte du numéro d'un contact indépendamment de la casse du nom.

Pièges courants

• Dans l'exercice 1, ne pas oublier d'initialiser sommet à null dans le constructeur.
• Attention à ne pas dépiler une pile vide, ce qui provoquerait une exception.
• Dans l'exercice 2, la pile non générique PileTab a une taille fixe de 4 ; dépasser cette taille affiche un message d'erreur sans planter le programme.
• Dans l'exercice 3, la méthode sommet() doit retourner l.peek() et non dépiler l'élément.
• Dans l'exercice 4, bien gérer l'ajout et la suppression des sous-tâches pour que le coût soit correct.
• Pour l'annuaire, la méthode getnumero doit comparer les clés en ignorant la casse (equalsIgnoreCase) pour éviter les erreurs de recherche.
• Ne pas confondre les noms des variables et des méthodes, respecter la casse et la syntaxe Java.