Introduction -DAO

-Découplage de l’ application par rapport au syst. Stockage ( BD/LDAP/File syst.)

- favoriser des test unitaire sans avoir à utiliser les syst. de stockage

1
Java Collection
C'est quoi une collection ?
Des objets qui permettent de stocker d'autres objets
Collection sont décrits par des interfaces représentant les structures de
données logiques les plus couramment utilisées : les listes, les tableaux,
les ensembles,etc.
Algorithmes constituant des méthodes standards fournissant des
opérations comme le tri, la recherche, etc.

Structures de données
C'est l'organisation efficace d'un ensemble de données, sous la forme de
tableaux, de listes, de piles etc. Cette efficacité réside dans la quantité
mémoire utilisée pour stocker les données, et le temps nécessaire pour
réaliser des opérations sur ces données
Les collections permettent d’implémenter des structures de données
réutilisables et par conséquent accélérer le développement

2
En Java, il existe 3 sortes de structures de
données
1. Les tableaux : Structure de taille fixe, accès
direct aux élements
2. Les Collections
 Structure modifiable, différents algorithmes de
stockage
3. Les Map
 Structure modifiable, stocke des couples clé -> valeur

3
Collections & Java
Une collection gère un groupe d'un ensemble d'objets d'un type donné ; ou
bien c'est un objet qui sert à stocker d'autres objets.
Dans les premières versions de Java, les collections étaient représentées par
les "Array","Vector","Stack" etc.
Avec Java 1.2 (Java 2) est apparu le Framwork de collections apportant des
modifications dans la manière avec laquelle ces collections ont été réalisées et
hiérarchisées.
Algorithmes
Sont utilisés pour traiter les éléments d'un ensemble de données. Ils
définissent une procédure informatique, par exemple: Ajout, suppresion, tris,
recherche etc.
Itérateurs
Fournissent aux algorithmes un moyen pour parcourir une collection du début
à la fin. Ce moyen permet de retirer donc à la demande des éléments donnés
de la collection.

4
5
 Les listes, les ensembles, les piles, les files d’attente
sont des objets qui regroupe plusieurs éléments en
une seule entité.
: en commun : mêmes questions
◦ est-ce qu’elles contiennent des éléments ?
combien ?
◦ mêmes opérations : on peut ajouter ou enlever un
élément à la structure, on peut vider la structure. On
peut aussi parcourir les éléments contenus dans la
structure.
◦ implémentations différentes (polymorphisme)
Q : Comment peut-on manipuler toutes ces structures
? Rep : ➫ utiliser une hiérarchie d’interfaces

6
  

7
8
 Description des interfaces

public interface Collection {

// Operations de Bases
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(Object element); // Optional
boolean remove(Object element); // Optional
Iterator iterator(); //naviguer dans la collection
int hashCode(); //fonction de hashage
boolean equals(Object element);
// Operations de masse
boolean containsAll(Collection c);
boolean addAll(Collection c); // Optional
boolean removeAll(Collection c); // Optional
boolean retainAll(Collection c); // Optional
void clear(); // Optional
// Operations sur les tableaux
Object[] toArray();
Object[] toArray(Object a[]);
}
  9
  Ces interfaces sont génériques, i.e. on peut leur donner un
paramètre pour indiquer qu’on a une collection de Employe,
de integer, de String, etc...
 En utilisant la généricité ➫ le compilateur va connaître le
type des éléments qui sont contenus dans la collection.
 Situation :
◦ On a une collection maCollection qui contient des objets de type E. On
va accéder à chaque élément de la collection maCollection en utilisant
le mot-clé for, chaque élément sera stocké dans une variable<nom> de
type E (évidemment).
◦ Exemple : boucle for pour les collections
;Collection maCollection
...
for (E <nom>: maCollection)
}block d’instructions //{

10
 Divers Type de Collection
Les Tableaux
Un tableau est une liste d'éléments. Ce n'est pas une collection en soi,
car un tableau n'implémente pas l'interface Collection.
La taille et le type des éléments d'un tableau sont fixés à la création.
Contrairement à une vraie collection, un tableau n'accepte pas
forcément que les objects, mais peut aussi accepter un type primitif
comme int ou char.
Un tableau n'est pas Thread Safe à la base, c'est à dire qu'il n'a pas de
protection particulière dans son implémentation
Ex. si deux Threads accèdent en même temps au tableau et qu'au moins l'un d'entre eux
le modifie.

Voici l'exemple d'opérations sur un tableau d'entiers :

int [] monTableau = new int[20] ; // création d'un tableau de 20 entiers

monTableau[0]=15 ; // insertion au premier index de l'entier 15
System.out.println("Mon entier vaut : " + monTableau[0]) ; // affichage

11
 Les Lists
Une liste est une collection ordonnée. L'utilisateur de celle-ci
a un contrôle complet sur les éléments qu'il insère dedans, et
il peut y accéder par l'entier de leur index. Les listes ont
toujours comme premier élément 0.
1- Les Listes Chaînées (LinkedList)
Une liste chaînée est une liste dont chaque élément est relié
au suivant par une référence à ce dernier.
Une liste chaînée peut être utilisée dans le cadre d'une
simulation de pile ou de file, FIFO(First In First Out) ou
FILO(First In Last Out).
La taille d'une LinkedList n'est pas fixe : on peut ajouter et
enlever des éléments selon nos besoins. Nous pouvons aussi
remarquer que les LinkedList acceptent tous types d'objets.
LinkedList n'est pas Thread Safe. Pour bien comprendre le
principe des listes chaînées, rien de mieux qu'un petit schéma
:
12
13
List maListe=new LinkedList() ; // on crée notre liste chaînée
maListe.add(new Integer(1)) ; // on ajoute l'entier 1 à la liste
maListe.add(new Float(2.15)) ; // on ajoute le flottant 2.15 à la liste
/* On remarque ici que l'entier 1 est la tête de la liste, et que le flottant est
la queue de la liste. */
Integer monEntier=(Integer)maListe.getFirst() ; // on n'oublie pas de faire
le cast
Float monFloat=(Float)maListe.getLast(); // on n'oublie pas de faire le cast
maListe.remove(0) ; // on retire l'entier , le flottant devient la tête

14
 Les opérations principales sur une liste chaînée

add(Object o) : ajoute un objet o en fin de liste

addFirst(Object o) : ajoute un objet o en début de
liste
 addLast(Object o) : ajoute un objet o en fin de liste
 clear() : vide la liste
 contains(Object o) : renvoie true si la liste contient
l'objet o, false sinon.
getFirst() et getLast() : renvoie le premier et le
dernier élément de la liste sous forme d'Object. Ne
pas oublier le cast.
 removeFirst() et removeLast() : retire le premier et le
dernier élément de la liste.
 size() : renvoie la taille de la liste

15
 Les ArrayList
 Un ArrayList est un tableau qui se redimensionne automatiquement. Il accepted
tout type d'objets, null y compris.
 Chaque instance d'ArrayList a une capacité, qui définit le nombre d'éléments qu'on
peut y stocker. Au fur et à mesure qu'on ajoute des éléments et qu'on " dépasse " la
capacité, la taille augmente en conséquence. ArrayList n'est pas Thread Safe.
List monArrayList = new ArrayList(10) ; // on crée un ArrayList de taille 10
for(int i=0;i<30;i++) {
monArrayList.add(new Integer(i)); // on ajoute 30 entiers
}
/* On remarque que le ArrayList , au moment d'ajouter
/*10, atteint sa capacité maximale, il se redimensionne pour en accepter plus */
Les opérations principales sur un ArrayList
add(Object o) : ajoute l'objet o à la fin du ArrayList
clear() : vide le ArrayList
get(int index) : renvoie l'Object à l'index spécifié. Renvoie une exception si vous dépassez le
tableau (IndexOutOfBoundsException)
size() : renvoie la taille du ArrayList

16
LinkedList queue = new LinkedList();
queue.addFirst("Bernadine");
queue.addFirst("Elizabeth");
queue.addFirst("Gene");
queue.addFirst("Elizabeth");
queue.addFirst("Clara");
System.out.println(queue);
queue.removeLast();
queue.removeLast();
System.out.println(queue);}}
Affichage
=======
[Clara, Elizabeth, Gene, Elizabeth,
Bernadine]
[Clara, Elizabeth, Gene]
import java.util.*;
public class ListExample {
public static void main(String args[]) {
List list = new ArrayList();
list.add("Bernadine");
list.add("Elizabeth");
list.add("Gene");
list.add("Elizabeth");
list.add("Clara");
System.out.println(list);
System.out.println("2: " + list.get(2));
System.out.println("0: " + list.get(0));
Affichage
=======
[Bernadine, Elizabeth, Gene, Elizabeth,
Clara]
2 : Gene
0 : Bernadine
17
Comparaison entre Tableau (Array)et
ArrayList

18
Les collections de type Set

Un Set est une collection qui n'accepte pas

les doublons, et au maximum une fois null.
Cela veut dire que deux éléments e1 et e2 d'un
Set ne seront pas égaux par e1.equals(e2).
TreeSet:les éléments sont rangés de manière
ascendante.
HashSet: les éléments sont rangés suivant
une méthode de hachage.

19
 Les HashSet

HashSet est l'implémentation la plus utile

de Set. Elle permet de stocker des objets
sans doublons.
Pour parcourir un HashSet, on est obligé
d'utiliser un Iterator. Il est à signaler que
les Map qui seront expliquées plus Bas
utilisent les Set pour garder les clés
uniques.
Exemple d'opérations sur un HashSet

20
Remarque :
le double bob de la liste est éliminer dans le set

21
 Exemple 1
Set monHashSet=new HashSet(); // on crée notre Set
monHashSet.add(new String("1")); // on ajoute des string quelconques
monHashSet.add(new String("2"));
monHashSet.add(new String("3"));
monHashSet.add(new String("1")); // oups, je l'ai déja ajouté, la fonction
gère l'exception levée,et l'objet n'est pas ajouté
Iterator iter=monHashSet.iterator(); // on crée un Iterator pour parcourir
notre HashSet
while(iter.hasNext()) // tant qu'on a un suivant
{System.out.println(iter.next()); // on affiche le suivant }
/* Notez que l'itération se fait aléatoirement. */

22
import java.util.*;
public class SetExample {
public static void main(String args[]) {
Set set = new HashSet(); // Une table de Hachage
set.add("Bernadine");
set.add("Elizabeth");
set.add("Gene");
set.add("Elizabeth");
set.add("Clara");
System.out.println(set);
Set SetTrie = new TreeSet(set); // Un Set trié
System.out.println(sortedSet);}}
Résultat:
[Gene, Clara, Bernadine, Elizabeth]
[Bernadine, Clara, Elizabeth, Gene]
23
 Les collections de type Map
Une map est une collection qui associe une clé à une
valeur.
La clé est unique, contrairement à la valeur qui peut être
associée à plusieurs clés.
La majorité des collections de type Map ont deux
constructeurs :
1. un constructeur sans paramètre créant une Map vide, et
2. un constructeur prenant en paramètre une Map qui crée une
nouvelle Map en fonction de la Map passée en paramètre.

24
 Les HashTable
Problématique : Tableaux (taille fixe) List( recherche-> temps dépendant de la taille de list)
Peut-on trouver une structure de données dont la Recherche, Insertion et Suppression d’un élèment
s’effectue en temps constant ???
◦ Réponse : HashTable= Tableau couplé avec une fonction de Hachage fh qui garantit un temps constant pour les
opérations de base (Recherche, Insertion et Suppression etc…)
◦ La fh doit prendre en compte les collisions ç-à-d de keyValue possède même index dans le tableau

Si une collision se produit il va augmenter de façon linéaire le nb des collusions

Un HashTable est une implémentation de Map qui associe une clé à une valeur. N'importe quel
objet, mis à part null peut y être ajouté.

25
Exemple d'utilisation de HashTable, où on associe un numéro de
mois à son nom
Map monHashtable = new Hashtable() ;
monHashtable.put(new Integer(1),"Janvier");
monHashtable.put(new Integer(2),"Fevrier");
monHashtable.put(new Integer(3),"Mars");
monHashtable.put(new Integer(4),"Avril");
monHashtable.put(new Integer(5),"Mai");
monHashtable.put(new Integer(6),"Juin");
monHashtable.put(new Integer(7),"Juillet");
monHashtable.put(new Integer(8),"Aout");
monHashtable.put(new Integer(9),"Septembre");
monHashtable.put(new Integer(10),"Octobre");
monHashtable.put(new Integer(11),"Novembre");
monHashtable.put(new Integer(12),"Décembre");

26
import java.util.Hashtable;
 public class MyHashtableOperations {
     public static void main(String a[]){
        //Create hashtable instance
        Hashtable<String,String> ht = new Hashtable<String,String>();
        //add key-value pair to hashtable
        ht.put("first", "FIRST INSERTED"); ht.put("second", "SECOND INSERTED"); ht.put("third","THIRD
INSERTED"); System.out.println(ht);
Affichage
{third=THIRD INSERTED, second=SECOND INSERTED, first=FIRST INSERTED}
         //getting value for the given key from hashtable
        System.out.println("Value of key 'second': "+ht.get("second"));
Affichage
Value of key 'second': SECOND INSERTED
        System.out.println("Is Hashtable empty? "+ht.isEmpty());
Affichage
Is Hashtable empty? false
        ht.remove("third");
        System.out.println(ht);
Affichage
{second=SECOND INSERTED, first=FIRST INSERTED}
        System.out.println("Size of the Hashtable: "+ht.size());
Size of the Hashtable: 2 27
Set<String> keys = ht.keySet();
for(String key: keys)
{  System.out.println("Value of "+key+" is: "+ht.get(key));        }
Affichage
Value of third is: THIRD INSERTED
Value of second is: SECOND INSERTED
Value of first is: FIRST INSERTED

for(String key: keys)

{   System.out.println(key);       }  

Affichage des cles

third
second
first
 } }

28
import java.util.HashMap;
import java.util.Hashtable;
 
public class MyHashtableCopy {
 
    public static void main(String args[]){
        Hashtable<String, String> ht = new Hashtable<String, String>();
        //add key-value pair to Hashtable
        ht.put("first", "FIRST INSERTED");
        ht.put("second", "SECOND INSERTED");
        ht.put("third","THIRD INSERTED");
        System.out.println(ht);
Affichage
{third=THIRD INSERTED, second=SECOND INSERTED, first=FIRST INSERTED}
        HashMap<String, String> subMap = new HashMap<String, String>();
        subMap.put("s1", "S1 VALUE");
        subMap.put("s2", "S2 VALUE");
        ht.putAll(subMap);
        System.out.println(ht);
    }
}
Affichage
{s2=S2 VALUE, third=THIRD INSERTED, second=SECOND INSERTED, s1=S1 VALUE,
first=FIRST INSERTED}

29
 Navigation dans la collection : les Iterator
Interface de navigation
public interface Iterator {
boolean hasNext();
Object next();
void remove(); // Optional}
hasNext
 permet de vérifier s'il y a un élément qui suit.
next permet de pointer l'élément suivant.

remove permet de retirer l'élément courant

Par exemple, 
le parcours collection d’une manière générale peut se faire de la manière suivante :

Collection collection = ...;

Iterator iter = collection.iterator();
while (iter.hasNext()) {
Object element = iter.next();
if (removalCheck(element)) { iter.remove();}}

 
30
 Exemple pour list

Pour parcourir une liste, il faut définir un Itérateur

spécialement pour la liste.
public interface ListIterator extends Iterator {
boolean hasNext();
Object next();
boolean hasPrevious();
Object previous();
int nextIndex();
int previousIndex();
void remove(); // Optional
void set(Object o); // Optional
void add(Object o); // Optional}

31
 Iterateur List
List list = ...;
ListIterator iter = list.listIterator(list.size());
while (iter.hasPrevious()) {
Object element = iter.previous();
// traitement d'un élément}
Remarque :  les  Maps  n'implémentant  pas  
l'interface  Iterable, ils  ne permettent  pas  d'être
parcourus à l'aide d'un itérateur. Toutefois, il sera possi
ble de le faire en convertissant chaque Map, à l'aide
de la méthode values, en une Collection
équivalente (qui, elle, implémente l'interface Iterable) .

32
Exemple pour MAP
Itérateure sur les Map
si hm est un HashMap alors:
 boucle sur les clés
for (String key : ht.keySet()) System.out.println("clé: "+key);

 boucle sur les valeurs

for (String key : ht.values()) System.out.println("valeurs :"+key);//

 boucle sur la paire clé/valeur

for (Map.Entry<String, String> entry : ht.entrySet())
{ System.out.println(entry.getKey() + "/" + entry.getValue()); }

33
Exercice
On souhaite enregistrer les objets créés à partir de la classe UserData
dans une Map (Hashtable()) en utilisant le champ email comme clé.
 Enregistrer les 3 objets créés dans le Map(Hashtable);
 Ecrire les instructions permettant de parcourir et afficher le
Hashtable par clé;
 Ecrire les instructions permettant de parcourir et afficher le
Hashtable par valeur
 Ecrire les instructions permettant de parcourir et afficher le
Hashtable par (clé et valeur)

Fin

34