Programmation Orientée Objet
Séminaire de formation animé par:
OUESLATI Belhassen
E-mail : [Link]@[Link]
Contenu pédagogique
Chapitres Thèmes
Chapitre 1 Introduction au langage JAVA
Chapitre 2 Classes et objets
Chapitre 3 Héritage
Chapitre 4 Le polymorphisme
Chapitre 5 Les interfaces
Chapitre 6 Les exceptions
Chapitre 7 Les collections
Déroulement du cours
Structuration du cours
Présentation des concepts
Illustration avec de nombreux exemples
Des bulles d’aide tout au long du cours :
Ceci est une alerte Ceci est une astuce
Mise en place du cours
Ancien cours de Francis Jambon
Cours de Fabrice Depaulis
Livre : Programmer en Java 2ème édition
Livre :Java2-LeGuideDuDeveloppeur
Internet : [Link]
[Link], Octobre 2015
Programmation Orientée Objet
Chapitre 7 : Les collections
[Link], Octobre 2015
Les collections
Pour l’instant nous avons étudié le tableau pour structurer les
données
Taille statique
Lent pour la recherche d’éléments particuliers
Impossibilité d’utiliser un pattern de déplacement dans les éléments
Java propose depuis la version 2 des classes permettant de manipuler
les principales structures de données
Les tableaux dynamiques implémentées par ArrayList et Vecto
Les listes implémentées par LinkedList
Les ensembles implémentées par HashSet et TreeSet
[Link], Octobre 2015
Les collections
Ces classes implémentent toutes indirectement une même interface
Collection qu’elles complètent de fonctionnalités propres
Collection << Interface >>
LinkedList
TreeSet HashSet
HashSet ArrayList
Depuis la version 5 de Java, possibilité d’utiliser les génériques pour
typer le contenu des Collections
Avant : Voiture maVoiture = (Voiture)[Link](2)
Maintenant : Voiture maVoiture = [Link](2)
Plus de problème de
conversion explicite
Les collections
L’interface Collection permet
La généricité et références : possibilité de stocker des éléments de type
quelconque, pour peu qu’il s’agisse d’objets. Un nouvel élément introduit dans
une collection Java est une référence à l’objet et non une copie
Les itérateurs : ils permettent de parcourir un par un les différents éléments
d’une collection
Efficacité des opérations sur des collections
Opérations communes à toutes les collections : les collections que nous allons
étudier implémentent toutes au minimum l’interface Collection, de sorte
qu’elle disposent de fonctionnalités communes
[Link], Octobre 2015
Les collections : les génériques Java
Avec la version 5 de Java possibilité d’exploiter les génériques dans
les collections et pour d’autres aspects du langage également
Une syntaxe particulière a été rajoutée de manière à prendre en
considération les génériques
< ? > : signale qu’il faut préciser le type de la classe
< ? , ? > : signale qu’il faut préciser deux types
Avec les génériques il va être possible de fixer à la construction de la
collection le type du contenu stocké dans les collections
Avanages
Toutes les méthodes accesseurs et modifieurs qui manipulent les éléments d’une
collection sont signés suivant le type défini à la construction de la collection
Vérification des types pendant le développement (avant problème de
CastClassException)
[Link], Octobre 2015
Les collections : I terator
Les itérateurs permettent de parcourir les éléments d’une collection
sans connaissance précise du type de la collection : Polymorphisme
Il existe deux familles d’itérateurs :
Monodirectionnels
Le parcours de la collection se fait d’un début vers une fin; on ne passe
qu’une seule fois sur chacun des éléments
bidirectionnels
Le parcours de la collection peut se faire dans les deux sens ; on peut
avancer et reculer à sa guise dans la collection
La notion d’Iterator
fait partie de l’ensemble
des Design Patterns
Les collections : I terator
Itérateur monodirectionnel : interface Iterator
Par défaut, toutes collections possèdent un attribut de type Iterator
Vérifie s’il y a un Iterator << Interface >>
prochain Permet d’obtenir
+ hasNext() : booléen
l’objet courant et
+ next() : < ? >
Supprime le dernier + remove() passe au suivant
objet renvoyé par
next()
c est une collection
et on récupère son
Iterator iter = [Link](); Iterator
while ([Link]()) {
On vérifie s’il y a On récupère l’objet
??? o = [Link]();
possibilité de ... courant puis on
récupérer un objet } passe au suivant
[Link], Octobre 2015
Les collections : I terator
Itérateur bidirectionnel : interface ListIterator
Cela concerne les listes et les tableaux dynamiques Iterator << Interface >>
Permet d’ajouter et de supprimer des objets
Vérifie s’il y a un ListIterator << Interface >>
précédent
+ previous() : < ? >
Ajoute ou modifie à la
+ hasPrevious() : booléen
+ add(< ? >)
position courante un
+ set(< ? >) élément de la collection
On vérifie s’il y a
+…
possibilité de
récupérer un objet c est une collection
précédemment et on récupère son
Iterator iter = [Link](); ListIterator
Initialise en début
while ([Link]()) {
Récupère l’objet de liste
précédemment puis on ??? o = [Link]();
...
passe au précédent }
[Link], Octobre 2015
Les collections : LinkedList
Cette classe permet de manipuler des listes dites « doublement
chaînées ».
A chaque élément de collection, on associe implicitement deux
informations qui sont les références à l’élément précédent et suivant
… c a c a b a b …
LinkedList<String> l1 = new LinkedList<String>();
ListIterator iter = [Link]();
Ajout des éléments
Plus rien [Link]("Bonjour");
[Link]("Coucou"); au travers de
après ses
l’itérateur
éléments, while([Link]()) {
on fait un String o = [Link](); L’utilisation de la
[Link](o);
retour en }
LinkedList est
arrière transparente
[Link], Octobre 2015
Les collections : LinkedList
Possibilité d’utiliser les collections (ici LinkedList est un exemple)
sans les itérateurs mais moins performant !!!
LinkedList<String> l1 = new LinkedList<String>();
L’utilisation
de la
[Link]("Bonjour");
[Link]("Coucou");
LinkedList
n’est pas
for (int i = 0; i < [Link](); i++) { transparente.
String o = [Link](i);
[Link](o); Connaissance
} obligatoire de
Utilisation ces méthodes
de la
méthode
add de la Ne pas modifier la collection
(add de LinkedList) pendant
classe
qu’on utilise l’itérateur (next())
LinkedList
[Link], Octobre 2015
Les collections : ArrayList
La classe ArrayList est une encapsulation du tableau avec la
possibilité de le rendre dynamique en taille
Possibilité d’utiliser des ListIterator mais on préfère son utilisation à
un élément de rang donné
ArrayList<Object> myArrayList = new ArrayList<Object>();
[Link]("Coucou"); [Link](34);
for (int i = 0; i < [Link](); i++) { Object
myObject = [Link](i);
if (myObject instanceof String) {
[Link]("Chaîne:" + ((String)myObject));
}
if (my_object instanceof Integer) {
[Link]("Integer:" + ((Integer)myObject));
}
}
Préférer l’utilisation de la
classe ArrayList au lieu de la
classe Vector 208
Les collections : HashSet
La classe HashSet permet de gérer les ensembles. Deux éléments ne
peuvent être identiques
Il faut prévoir deux choses dans vos classes :
La redéfinition de la méthode hashCode() qui est utilisée pour ordonnancer
les éléments d’un ensemble (calcul la table de hachage d’un objet)
La redéfinition de la méthode equals(Object) qui compare des objets de
même classe pour connaître l’appartenance d’un élément à l’ensemble
public class TestHashSet {
public static void main(String[] argv) {
Point p1 = new Point(1,3), p2 = new Point(2,2); Point p3
= new Point(4,5), p4 = new Point(1,8); Point p[] = {p1,
p2, p1, p3, p4, p3}
public static void affiche(HashSet ens) {
HashSet<Point> ens = new HashSet<Point>(); for (int i
Iterator iter = [Link]();
= 0; i<[Link]; i++) {
while([Link]()) {
[Link]("Le Point ") ; p[i].affiche();
Point p = [Link](); [Link]();
boolean ajoute = [Link](p[i]);
}
if (ajoute) [Link](" a été ajouté");
[Link]();
else [Link]("est déjà présent");
}
[Link]("Ensemble = "); affiche(ens);
}
}
}
[Link], Octobre 2015
Les collections : HashSet
public class Point {
private int x,y;
Point(int x, int y) {
Redéfinition des
this.x = x; this.y = y; méthodes hashCode() et
}
public int hashCode() { equals(Object)
return x+y;
}
public boolean equals(Object pp) {
Point p = (Point)pp;
return ((this.x == p.x) & (this.y
== p.y));
}
public void affiche() {
[Link]("[" + x + " "
+ y + "] ");
}
}
[Link], Octobre 2015