Vous êtes sur la page 1sur 29

Java Collection

C'est quoi une collection ?


Des objets qui permettent de stocker d'autres objets
Collection sont dcrits par des interfaces
reprsentant les structures de donnes logiques les
plus couramment utilises : les listes, les tableaux,
les ensembles,etc.
Structures de donnes
C'est l'organisation efficace d'un ensemble de
donnes, sous la forme de tableaux, de listes, de
piles etc. Cette efficacit rside dans la quantit
mmoire utilise pour stocker les donnes, et le
temps ncessaire pour raliser des oprations sur ces
donnes
1

Collections & Java


Une collection gre 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 premires versions de Java, les collections taient
reprsentes par les "Array","Vector","Stack" etc.
Avec Java 1.2 (Java 2) est apparu le Framwork de collections
apportant des modifications dans la manire avec laquelle ces
collections ont t ralises et hirarchises.
Algorithmes
Sont utiliss pour traiter les lments d'un ensemble de
donnes. Ils dfinissent une procdure informatique, par
exemple: Ajout, Delete, tris, recherche etc.
Itrateurs
Fournissent aux algorithmes un moyen pour parcourir une
collection du dbut la fin. Ce moyen permet de retirer donc
la demande des lments donns de la collection.

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[]);
}

Divers Type de Collection


Les Tableaux
Un tableau est une liste d'lments. Ce n'est pas une collection
en soi, car un tableau n'implmente pas l'interface Collection.
La taille et le type des lments d'un tableau sont fixs la
cration.
Contrairement une vraie collection, un tableau n'accepte pas
forcment 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 particulire dans son implmentation
Ex. si deux Threads accdent en mme temps au tableau et qu'au moins l'un
d'entre eux le modifie.
Voici

l'exemple d'oprations sur un tableau d'entiers :

int [] monTableau = new int[20] ; // cration 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
7

Lists
Une

liste est une collection ordonne. L'utilisateur de


celle-ci a un contrle complet sur les lments qu'il
insre dedans, et il peut y accder par l'entier de
leur index. Les listes ont toujours comme premier
lment 0.

1- Les Listes Chanes (LinkedList)


Une liste chane est une liste

dont chaque lment


est reli au suivant par une rfrence ce dernier.
Une liste chane peut tre utilise 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 lments 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 chanes, rien de mieux qu'un petit schma :
8

List maListe=new LinkedList() ; // on cre notre liste chane


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 tte 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

tte

10

Les oprations principales sur une liste chane


add(Object

o) : ajoute un objet o en fin de liste


addFirst(Object o) : ajoute un objet o en dbut 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 lment de la liste sous forme d'Object. Ne
pas oublier le cast.
removeFirst() et removeLast() : retire le premier et le
dernier lment de la liste.
size() : renvoie la taille de la liste
11

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 dfinit le nombre


d'lments qu'on peut y stocker. Au fur et mesure qu'on ajoute
des lments et qu'on " dpasse " la capacit, la taille augmente en
consquence. ArrayList n'est pas Thread Safe.

List monArrayList = new ArrayList(10) ; // on cre 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 oprations 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 spcifi. Renvoie une exception si
vous dpassez le tableau (IndexOutOfBoundsException)

size() : renvoie la taille du ArrayList


12

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
13

Comparaison entre Tableau


(Array)et ArrayList

14

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 associe plusieurs cls.
La majorit des collections de type Map ont
deux constructeurs :
1.
2.

un constructeur sans paramtre crant une Map


vide, et
un constructeur prenant en paramtre une Map
qui cre une nouvelle Map en fonction de la Map
passe en paramtre.

15

Les HashTable
Problmatique : Tableaux (taille fixe) List( recherche-> temps dpendant de la taille de list)
Peut-on

trouver une structure de donnes dont la Recherche, Insertion et


Suppression dun lment seffectue en temps constant ???
Rponse : HashTable= Tableau coupl avec une fonction de Hachage fh qui garantit un temps
constant pour les oprations de base (Recherche, Insertion et Suppression etc)
La fh doit prendre en compte les collisions --d de keyValue possde mme index dans le
tableau

Si

une collision se produit il va augmenter de faon linaire le nb des collusions

Un

HashTable est une implmentation de Map qui associe une cl une valeur.
N'importe quel objet, mis part null peut y tre ajout.

16

Exemple d'utilisation de HashTable, o on associe un


numro de mois son nom
Map monHashtable = new Hashtable() ;
monHashtable.put(new Integer(1),"Janvier");
monHashtable.put(new Integer(2),"Fevrier");
monHashtable.put(new
monHashtable.put(new
monHashtable.put(new
monHashtable.put(new
monHashtable.put(new

Integer(3),"Mars");
Integer(4),"Avril");
Integer(5),"Mai");
Integer(6),"Juin");
Integer(7),"Juillet");

monHashtable.put(new
monHashtable.put(new
monHashtable.put(new
monHashtable.put(new
monHashtable.put(new

Integer(8),"Aout");
Integer(9),"Septembre");
Integer(10),"Octobre");
Integer(11),"Novembre");
Integer(12),"Dcembre");
17

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);
//getting value for the given key from hashtable
System.out.println("Value of key 'second': "+ht.get("second"));
System.out.println("Is Hashtable empty? "+ht.isEmpty());
ht.remove("third");
System.out.println(ht);
System.out.println("Size of the Hashtable: "+ht.size());

Set<String> keys = hm.keySet();

for(String key: keys){System.out.println("Value of "+key+" is:


"+hm.get(key));}
for(String key: keys){System.out.println(key);}} }
Affichage
{third=THIRD INSERTED, second=SECOND INSERTED, first=FIRST INSERTED} Value of key 'second':
SECOND INSERTED Is Hashtable empty? false {second=SECOND INSERTED, first=FIRST INSERTED}
Size of the Hashtable: 2
Value of third is: THIRD INSERTED
Value of second is: SECOND INSERTED
Value of first is: FIRST INSERTED
Third
18
second

import java.util.HashMap;
import java.util.Hashtable;

public class MyHashtableCopy {

public static void main(String a[]){


Hashtable<String, String> hm = new Hashtable<String, String>();
//add key-value pair to Hashtable
hm.put("first", "FIRST INSERTED");
hm.put("second", "SECOND INSERTED");
hm.put("third","THIRD INSERTED");
System.out.println(hm);
HashMap<String, String> subMap = new HashMap<String, String>();
subMap.put("s1", "S1 VALUE");
subMap.put("s2", "S2 VALUE");
hm.putAll(subMap);
System.out.println(hm);
}
}
Affichage
{third=THIRD INSERTED, second=SECOND INSERTED, first=FIRST
INSERTED}
{s2=S2 VALUE, third=THIRD INSERTED, second=SECOND INSERTED, s1=S1
VALUE, first=FIRST INSERTED}
19

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 lments e1 et e2
d'un Set ne seront pas gaux par
e1.equals(e2).
TreeSet: les lments sont rangs de
manire ascendante.
HashSet: les lments sont rangs
suivant une mthode de hachage.
20

Les HashSet
HashSet

est l'implmentation 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 expliques
plus haut utilisent les Set pour
garder les cls uniques.
Exemple d'oprations sur un
HashSet
21

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

22

Exemple 1
Set monHashSet=new HashSet(); // on cre 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 dja
ajout, la fonction gre l'exception leve,et l'objet
n'est pas ajout
Iterator i=monHashSet.iterator(); // on cre un Iterator
pour parcourir notre HashSet
while(i.hasNext()) // tant qu'on a un suivant
{System.out.println(i.next()); // on affiche le suivant
}/* Notez que l'itration se fait alatoirement. */
23

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);}}
Rsultat:
[Gene, Clara, Bernadine, Elizabeth]
[Bernadine, Clara, Elizabeth, Gene]
24

Navigation dans la collection : les Iterator


Interface de navigation
public interface Iterator {
boolean hasNext();
Object next();
void remove(); // Optional}
hasNext permet de vrifier s'il y a un lment qui suit.
next permet de pointer l'lment suivant.
remove permet de retirer l'lment courant
Parexemple,
leparcoursd'unelistenommeliste1peutsefairedelamaniresuivante:
ListIteratorit=liste1.listIterator();
while(it.hasNext()) { Objectobj=it.next(); }
Exemple
Collection collection = ...;
Iterator it = collection.iterator();
while (it.hasNext()) {
Object element = it.next();
if (removalCheck(element)) { it.remove();}}

25

Exemple pour list


Pour parcourir une liste, il faut dfinir un
itrateur spcialement 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}
26

Iterateur List
List list = ...;
ListIterator iterator = list.listIterator(list.size());

while (iterator.hasPrevious()) {
Object element = iterator.previous();
// traitement d'un lment}

Remarque: les Maps n'implmentant pas


l'interface Iterable,ils nepermettent pas d'tre
parcourusl'aided'unitrateur.Toutefois,ilser
apossibledelefaireenconvertissantchaqueM
ap,l'aide
delamthodevalues,enuneCollection
quivalente(qui,elle,implmentel'interfaceIte
rable).
27

Exemple pour MAP


Itrateure sur les Map
si m est un HashMap alors:

// sur les cls


for (Iterator i = m.keySet().iterator();i.hasNext();)
System.out.println(i.next());
// sur les valeurs
for (Iterator i = m.values().iterator();i.hasNext();)
System.out.println(i.next());
// sur la paire cl/valeur
for (Iterator i = m.keySet().iterator();i.hasNext();){
Map.Entry e = (Map.Entry) i.next();
System.out.println(e.getKey() + " ; " + e.getValue());
}

28

Exercice
On souhaite enregistrer les objets crs partir de la
classe UserData dans une Map (Hashtable()) en
utilisant le champ email comme cl.

Enregistrer les 3 objets crs 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

29