Vous êtes sur la page 1sur 4

Faculté d’Electronique & d’Informatique Année 2020/2021

Département Informatique
3 ème Année Licence ISIL /

TP 01 : Collections et autres structures de données


Exercice 01 : Listes triées
Écrivez un programme qui construit une collection triée contenant n nombres entiers (représentés par des
objets Integer) tirés au hasard dont la valeur est comprise entre 0 et 1000. A votre choix, la valeur de n est
lue au début de l’exécution ou est un argument du programme. Ensuite, ce dernier affiche la collection
construite afin qu’on puisse constater qu’elle est bien triée.

− Dans la première version du programme la collection est une sorte de List (par exemple un
ArrayList ou une LinkedList) que vous triez, après la construction, en utilisant une méthode
statique ad hoc de la classe Collections.
− Dans une deuxième version, la collection est une sorte de Set (c’est-à-dire un HashSet ou un
TreeSet, mais avez-vous le choix ?) si bien qu’elle est constamment triée.

Remarque: Un entier tiré au hasard entre 0 et 100 : (int)(1000 * Math.random())

Exercice 02 : Modéliser un élève

Un élève sera ici modélisé par la classe Eleve de la façon suivante. La classe Eleve possède trois attributs
privés : son nom de type String, un ensemble de notes, nommé listeNotes, qui sont des entiers rangés
dans un ArrayList<Integer>, une moyenne de type double, qui doit toujours être égale à la moyenne des
notes contenues dans l’attribut listeNotes.
Un élève sans aucune note sera considéré comme ayant une moyenne nulle.
La classe Eleve possède un constructeur permettant uniquement d’initialiser le nom de l’élève.
La classe Eleve possède aussi cinq méthodes publiques :
– Un getter pour la moyenne de l’élève qui renvoie la valeur de l’attribut moyenne :
public double getMoyenne()
– Un getter pour le nom de l’élève qui renvoie le nom de l’élève: public String getNom()
– Un getter pour la liste des notes de l’élève qui renvoie la liste des notes de l’élève :
public ArrayList<Integer> getListeNotes()
– Une méthode qui ajoute la note reçue en paramètre à listeNotes ; si la note reçue en paramètre est
négative, la note introduite est 0 ; si la note reçue en paramètre est supérieure à 20, la note introduite est
20 ; la méthode actualise en conséquence l’attribut moyenne : public void ajouterNote(int note)
– Une méthode qui retourne une description de l’élève considéré (par exemple : ”Sophia (12.25)”).
public String toString() Une fois la méthode toString définie dans la classe Eleve, et si eleve est de
type Eleve, l’instruction : System.out.println(eleve); est équivalente à l’instruction :
System.out.println(eleve.toString());

Après avoir terminé la classe Eleve, écrire un programme qui teste cette classe.

1
Exercice 03 : Modéliser un élève comparable à autre

Cet exercice fait suite à l’exercice Modéliser un élève. Il s’agit ici de compléter la classe Eleve pour faire
en sorte d’avoir une classe qui implémente l’interface java.lang.Comparable<T>. C’est une interface
générique, comme l’indique le <T> mais il n’y a pas grand-chose à savoir sur le sujet pour l’utiliser. Il
faudra, en implémentant l’interface, indiquer à la place du T le type des objets qu’on veut comparer entre
eux.
L’interface Comparable<T> déclare une seule méthode :
public int compareTo (T o);
Quand cette méthode est implémentée, elle doit retourner une valeur strictement négative, nulle ou
strictement positive selon que l’objet concerné (celui qui correspond à la référence this) est plus petit que
l’objet o, égal à l’objet o ou plus grand que l’objet o.
On comparera les élèves selon leur moyenne (ou, si vous préférez, selon l’ordre alphabétique).
Pour cela, vous allez reprendre la classe Eleve écrite précédemment pour la transformer en une classe qui
implémente l’interface java.lang.Comparable<T>. Il faudra pour cela compléter l’en-tête de la classe
Eleve par ”implements Comparable<Eleve>”. Il faudra de plus définir la méthode compareTo déclarée
par l’interface Comparable. Cette méthode est à nouveau générique ; si la classe implémente
Comparable<Eleve>, le paramètre de la méthode doit être de type Eleve, l’en-tête est donc :
public int compareTo (Eleve autreEleve )
Le code de la méthode doit respecter la fonctionnalité décrite plus haut.
Après avoir ainsi complété la classe Eleve, modifiez aussi la méthode main de la classe TestEleve pour
tester la méthode compareTo.

Exercice 04 : Modéliser un groupe d’élèves

Un groupe d’élèves sera modélisé par la classe GroupeEleves. Cette classe possède un attribut privé : une
collection d’Eleve(s) nommée listeEleves, de type ArrayList<Eleve>.
La classe GroupeEleves possède les méthodes publiques suivantes :
– La méthode public int nombre() qui renvoie le nombre d’Eleve(s) contenus dans listeEleves
– La méthode public ArrayList<Eleve> getListe() qui renvoie listeEleves.
– La méthode public void ajouterEleve(Eleve eleve) qui ajoute l’Eleve reçu en paramètre à listeEleves.
– La méthode public Eleve chercher(String nom) qui renvoie l’Eleve dont le nom est indiqué par le
paramètre ; si plusieurs Eleve(s) ont même nom, la méthode renvoie le premier Eleve ayant ce nom
contenu dans listeEleves ; si aucun Eleve n’a le nom indiqué, la méthode retourne null. On pourra utiliser
la méthode equals de la classe String pour comparer une chaîne de caractères à une autre.
– La méthode public void lister() qui écrit à l’écran la liste des Eleve(s). Elle utilise une ligne par
Eleve; elle utilise la méthode toString de la classe Eleve.
– La méthode, nommée meilleurEleve, qui retourne l’élève de meilleure moyenne de la liste listeEleves;
– une méthode, nommée trierEleves, qui trie la liste listeEleves selon l’ordre croissant des moyennes des
élèves (ou selon le nom, si vous avez défini la méthode compareTo en comparant l’ordre alphabétique
des noms).

2
Remarque :
- L’instruction Collections.max(listeEleves) renvoie l’élève qui est ”le plus grand” par rapport à la
relation définie par la méthode compareTo dans la classe Eleve ;
- Collections.sort(listeEleves) trie listeEleve par ordre croissant selon la relation définie par la
méthode compareTo dans la classe Eleve ;
Ces méthodes peuvent être utilisées pour tout ArrayList d’objets implémentant l’interface Comparable.
Après avoir terminé la classe GroupeEleves, écrire un programme qui teste cette classe.

Annexe :
1. RELATION D’ORDRE

– L’interface Comparable. Dire d’une classe qu’elle implémente l’interface Comparable c’est dire que ses
instances forment un ensemble muni d’une relation d’ordre, donnée par l’unique méthode de cette
interface int compareTo(Object o) définie par : a.compareTo(b) est négatif, nul ou positif selon que la
valeur de a est inférieure, égale ou supérieure à celle de b.
– L’interface Comparator. Les implémentations de cette interface sont des relations qu’on passe comme
arguments aux méthodes qui utilisent ou créent des collections ordonnées. Cette interface comporte
essentiellement la méthode : int compare(Object o1, Object o2) définie, comme la précédente, par :
compare(a, b) est négatif, nul ou positif selon que la valeur de a est inférieure, égale ou supérieure à celle
de b.
Dans un cas comme dans l’autre, ces comparaisons supportent quelques contraintes (ce qui est dit ici sur
compare s’applique également à compareTo) :
– on doit avoir signe(compare(x,y)) == -signe(compare(y,x)) pour tout couple de valeurs x et y ;
– la relation est transitive : si compare(x,y) > 0 et compare(y,z) > 0 alors compare(x,z) > 0 ;
– si compare(x,y) == 0 alors signe(compare(x,z)) == signe(compare(y,z)) pour tout z ;
– en outre, bien que ce ne soit pas strictement requis, on fait généralement en sorte que (compare(x,y) ==
0) == x.equals(y)
Lorsque cette dernière contrainte n’est pas satisfaite, la documentation doit comporter l’avertissement
" Note : this comparator imposes orderings that are inconsistent with equals."

2. Trier une liste

Pour trier une liste nous pouvons :


– Soit faire en sorte que le type des éléments de la collection implémente l’interface Comparable
– Soit fournir un objet Comparator en argument de la méthode sort.
Nous nous intéressons au deuxième cas, c’est à dire à l’interface Comparator. Cette interface consiste en
une simple méthode :
public interface Comparator <T> {
int compare (T o1 , T o2 );
}
Il va de soi que le type T doit être d’un type compatible avec le type des éléments de la liste à trier.
Pour implémenter un objet Comparator, nous aurons besoin obligatoirement d’une classe (une interface
ne peut être instanciée directement).
3
Par exemple pour trier des objets de type Truc :
class ComparatorClient implements Comparator <Truc >{
@Override
public int compare ( Truc o1 , Truc o2) {
...
}
}
Les arguments de la méthode compare doivent eux aussi être d’un type compatible avec les éléments de la
liste à trier (de type Truc dans l’exemple ci-dessus).

Bon travail !

Vous aimerez peut-être aussi