Conception Orientée Objet & Programmation JAVA

Chapitre 8 : Les collections (LIST & SET)

ESPRIT - UP JAVA Année universitaire 2020/2021

 PLAN
• Introduction
• Classe et objet
• Encapsulation
• Héritage
• Polymorphisme
• Exceptions
• Interfaces
• Collection
• Interface Fonctionnelle
• Expression Lambda
• Stream

2
Les Collections

3
 Collection : Définition
✔ Les collections en java est un ensemble d'interfaces et classes qui aident à stocker, ordonner et traiter les
données efficacement.

✔Une structure collective implante une collection

→ plusieurs implantations possibles
❖ ordonnées ou non, avec ou sans doublons, ...
❖ accès, recherche, tris (algorithmes) plus ou moins efficaces

✔ Les classes et les interfaces se trouvent dans le paquetage : java.util.

4
 Collection : pourquoi?
✔Adapter la structure collective aux besoins de la collection

✔Les collections sont utilisés pour:

- stocker, rechercher et manipuler des données
- transmettre des données d’une méthode à une autre

✔Certaines collections acceptent les doublons, d'autres pas. Certaines sont ordonnées,
d'autres pas. Certaines collections émettent quelques restrictions, comme le type ou
l'interdiction de la valeur null. 5
Collections Vs. Tableaux statiques
•Tableau
-accès par index
-recherche efficace si le tableau est trié (dichotomie)
-défaut majeur : nombre d’éléments borné

•Collections
-accès séquentiel : premier, suivant
-insertions et suppressions rapide

6
Les Collections (Architecture)

7
 Architecture
Composée de 3 parties :

● Une hiérarchie d'interfaces permettant de représenter les collections

sous forme de types abstraits.

● Des implémentations de ces interfaces.

● Implémentation de méthodes liées aux collections (recherche, tri, etc.).

8
 Architecture
2 hiérarchies principales :

Collection MAP

9
Architecture

10
Interface « Collection »

11
Interface « Collection »

12
Collection: List

13
 List

- Les objets appartenant à la catégorie List sontdes tableaux extensibles à volonté.

On y trouve les objets Vector, LinkedList et ArrayList

- 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 leur index.

- Les listes ont toujours comme premier élément d’indice 0.

14
 ArrayList Vs. Vector
java.util.ArrayList java.util.Vector

- utilise un tableau en interne pour - Synchronisé par défaut (4x plus

ranger les données, lent que ArrayList)
- fournit un accès aux éléments par - est une classe dite "thread-safe",
leur indice très performant et est c'est-à-dire que plusieurs
optimisé pour des opérations processus peuvent l'utiliser en
d'ajout/suppression d'éléments en fin même temps sans risque de perte
de liste, de données.
- Les emplacements sont repérés par
des indice (à partir de 0)
15
 List
Déclaration + instanciation

● List monArrayList = new ArrayList(10)

● List monVector = new Vector()

Remarque: L’attribution de la taille d’un tableau dynamique est facultatif !

16
 List: ArrayList

- Un ArrayList est un tableau qui se redimensionne automatiquement. Il accepte

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.

17
 List: ArrayList

● Les opérations principales sur un ArrayList sont :

- 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
18
 List: ArrayList

- contains(Object o): renvoie true si la liste contient l'objet o, false sinon. La redéfinition de la
fonction equals(Object obj) est importante pour comparer deux objets selon leurs attributs.

- remove(Object o): Retirer un objet de la collection. La redéfinition de la fonction equals(Object obj)

est importante pour comparer deux objets selon leurs attributs.

19
Tri et recherche dans une LIST

20
 Collection Vs. Collections

- Collection est l'interface racine dans l'hiérarchie de java framework

Collections. Ce qui veut dire que chaque classe implémente Collection.

- Collections est une classe utilitaire membre de java framework Collections et

qui a des méthodes statiques pour manipuler les objets qui implémentent
l'interface List. Par exemple, le tri d'un ArrayList dans l'ordre croissant:

Collections.sort(arraylist);

21
 La classe Collections
La classe Collections est une classe utilitaire pour les collections Java. Cette classe
contient des méthodes statiques qui manipulent ou retournent des collections.

- trie (sur listes)

- recherches (sur listes)
- copies
- minimum et maximum

22
La classe Collections

23
 La classe Collections (Tri)

- Si la méthode sort(List) est utilisée, il faut obligatoirement que les éléments

inclus dans la liste implémentent tous l'interface Comparable sinon une
exception de type ClassCastException est levée.

- Plus exactement, la méthode sort() ne fonctionnera que si tous les éléments de la

liste sont d’une classe qui implémente l’interface
java.lang.Comparable<? super E>

24
L’interface Comparable<T>
- Interface pour définir un ordre de tri naturel pour un objet

- Redéfinir la méthode
public int compareTo (T o) avec

25
 Comparable: Exemple (1/2)
public class Student implements Comparable<Student>{ public void setName(String name) {
private String name; this.name = name;

}
public Student(){}

public Student(String name) { //Redéfinir la méthode compareTo()

this.name = name; @Override
} public int compareTo(Student s) {
public String getName() { return name.compareTo(s.getName());
return name; }
} }

26
Comparable: Exemple (2/2)
public class TestSort{

public static void main(String args[]){

//ajouter des éléments dans la liste studentList

List<Student> studentList = new ArrayList<Student>();

studentList.add(new Student("Alex"));

studentList.add(new Student("Bob"));

studentList.add(new Student("Ali"));

//Triez la liste en ordre croissant en fonction du nom

Collections.sort(studentList);

}
27
L’interface Comparator<T>
- Interface pour définir un ordre de tri quelconque

- Redéfinir la méthode
public int compare(T o1, T o2)

28
 Comparator: Exemple (1/2)

public class StudentComparatorByName implements

Comparator<Student>{

//Redéfinir la méthode compare() selon le name

@Override

public int compare(Student s1, Student s2) {

return s1.getName().compareTo(s2.getName());

29
Comparator: Exemple (2/2)
public class TestSort{

public static void main(String args[]){

//ajouter des éléments dans la liste studentList

List<Student> studentList = new ArrayList<Student>();

studentList.add(new Student("Alex"));

studentList.add(new Student("Bob"));

studentList.add(new Student("Ali"));

//Trier studentList selon le nom

Collections.sort(studentList, new StudentComparatorByName ());

} 30
Comparable Vs. Comparator

31
SET

32
 Set: Definition

- Set est une collection qui ne contient aucun élément en double. Plus formellement,
Set ne contiennent pas une paire d’éléments e1 et e2 tels que e1.equals(e2).

- Il stocke les éléments dans une table de hachage qui est un très bon atout pour les
haute performances, mais il ne garantie pas l'ordre d'insertion des éléments lors
de parcours.

33
Set: Definition
● Méthodes de Set<E>
- sens du hashCode à l’objet passé en paramètre sera enlevé
- la méthode add n’ajoute pas un élément si un élément égal est déjà dans l’ensemble

● Set : TreeSet et HashSet

Le choix entre ces deux objets est lié à la nécessité de trier les éléments :
- les éléments d'un objet HashSet ne sont pas triés : l'insertion d'un nouvel élément est rapide
- les éléments d'un objet TreeSet sont triés : l'insertion d'un nouvel élément est plus long

34
 Set: Définition
• L'interface Set définit les fonctionnalités d'une collection qui ne peut pas contenir de
doublons dans ses éléments.

• Les éléments ajoutés dans une collection de type Set doivent ré implémenter leurs
méthodes equals() et hashCode(). Ces méthodes sont utilisées lors de l'ajout d'un
élément pour déterminer s'il est déjà présent dans la collection.

• La valeur retournée par hashCode() est recherchée dans la collection : si aucun objet de
la collection n'a la même valeur de hachage alors l'objet n'est pas encore dans la
collection et peut être ajoutési un ou plusieurs objets de la collection ont la même valeur
de hachage alors la méthode equals() de l'objet à ajouter est invoquée sur chacun des
objets pour déterminer si l'objet est déjà présent ou non dans la collection

35
SET: Exemple (1/2)
import java.util.Set;
for(int i = 0; i<4; i++){
import java.util.HashSet;
hashset.add(count[i]);
import java.util.TreeSet;
}

System.out.println(hashset);
public class ExempleSet {

TreeSet treeset = new TreeSet(hashset);

public static void main(String args[]) {
System.out.println("La liste triée est:");
int count[] = {10, 20, 30, 40, 50};
System.out.println(treeset);
Set hashset = new HashSet();

}}

36
SET: Exemple (2/2)

37
 HashSet<E> (Exemple 1)
● HashSet est l'implémentation la plus utile de Set. Elle permet de stocker des objets sans doublons .

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")); // l'objet n'est pas ajouté

Iterator<String> i=monHashSet.iterator(); // on crée un Iterator pour parcourir notre HashSet

while(i.hasNext()) // tant qu'on a un suivant

{
System.out.println(i.next()); // on affiche le suivant
}
38
 HashSet<E> (Exemple 1-2)
● HashSet est l'implémentation la plus utile de Set. Elle permet de stocker des objets sans doublons .

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")); // l'objet n'est pas ajouté

for(String str :monHashSet)

{
System.out.println(str); // on affiche la chaîne
}

39
 HashSet<E> (Exemple 2-1)

Set myHashSet = new HashSet(); // on crée notre Set

myHashSet.add(new Student("Ali")); // on ajoute des étudiants

myHashSet.add(new Student("Sami"));
myHashSet.add(new Student("Mariem"));
myHashSet.add(new Student("Ali")); // Insertion impossible! L’étudiant Ali a été déjà ajouté (redéfinition de
equals() & hashCode())

Iterator<Student> i=myHashSet.iterator(); // on crée un Iterator pour parcourir notre HashSet

while(i.hasNext()) // tant qu'on a un suivant

{
System.out.println(i.next()); // on affiche le suivant
}
40
 HashSet<E> (Exemple 2-2)

Set myHashSet = new HashSet(); // on crée notre Set

myHashSet.add(new Student("Ali")); // on ajoute des étudiants

myHashSet.add(new Student("Sami"));
myHashSet.add(new Student("Mariem"));
myHashSet.add(new Student("Ali")); // Insertion impossible! L’étudiant Ali a été déjà ajouté (redéfinition de
equals() & hashCode())
for(Student etudiant:myHashSet)
{
System.out.println(etudiant); // on affiche la chaîne
}

41
 HashSet<E> (Exemple 2-3)

public int hashCode(){ final Student other = (Student) obj;

return 10;
} if (! (this.name.equals other.name)) {
return false;
public boolean equals(Object obj){ }
if (this == obj) { return true;
return true; }
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
42
 HashSet<E>

● Les éléments sont stockés dans une table de hashage .

● Cette classe ne vérifie l’égalité que pour les objets qui ont le même hashCode

● Il faut redéfinir les 2 méthodes equals(Object obj) et hashCode() afin d’assurer

l’unicité des éléments dans le HashSet

43
 HashCode: Définition

La méthode hashcode() est utilisé pour générer une valeur de code de hachage pour
un objet et cette valeur de code de hachage est utilisée par certaines classes de
collection pour comparer des objets, ce qui augmente les performances des grandes

collections d’objets.

44
 HashCode: Exemple
@Override

public int hashCode() {

int result = 17;

result = 31 * result + age;

return result;

→ L’utilisation de 31 comme hash est juste pour assurer que la valeur du hashcode sera différent pour
chaque objet. Vous devez calculer le hachage pour différents membres et renvoyer le total sous forme de
code de hachage unique.
45
 TreeSet: Définition

● La classe TreeSet, ajoutée à Java 1.2, stocke ses éléments de manière ordonnée
en les comparant entre-eux. Cette classe permet d'insérer des éléments dans
n'importe quel ordre et de restituer ces éléments dans un ordre précis lors de son
parcours.

● Une collection de type TreeSet ne peut pas contenir de doublons.

● utilise un arbre de recherche. Pour pouvoir utiliser un TreeSet, il faut que les
éléments soit comparables. Cette fonction est plus lente que HashSet
46
 TreeSet: Définition

● L'ordre des éléments de la collection peut être défini par deux moyens :

❏ l'ordre naturel des éléments s'ils implémentent l'interface Comparable

❏ l'ordre obtenu par l'utilisation d'une instance de type Comparator fournie en

paramètre du constructeur de la collection

47
TreeSet: Exemple

48
Merci pour votre attention

49