collections en java partie 1 - deptmedia.cnam.fr

Collections en Java – Partie 1

Virginia Aponte

CNAM-Paris

17 septembre 2021

Virginia Aponte (CNAM-Paris) NFA035 17 septembre 2021 1 / 46

Présentation des collections


Principes de l’infrastructure « Collections »

C’est quoi ? bibliothèque Java définissant des structures de données pourstocker/chercher/manipuler des objets via des algorithmesconnus et efficaces,

Exemples listes d’objets ; ensembles d’objets (ordonnés ou pas) ; files,piles, dictionnaires associant clés et valeurs, etc.

En détail une collection est un objet qui pointe vers ses objets membres.Ils sont organisés de diverses manières selon le type decollection. Une collection possède des opérations pourstocker/chercher des objets.

Réutilisables Leur définition est générique ⇒ leur code est réutilisable pourstocker tout type d’objet.

Où ? dans le paquetage java.util


Organisation de la infrastucture

PrincipeApproche unifiée pour représenter et manipuler les collections d’objets, quelque soit le type des objets, et la manière dont on les organise.

1 Hiérachie d’interfaces : chacune modélise un mode d’organiser lesobjets au sein de la collection

opérations adaptées à cet organisation,pour objets de toute sorte (génériques), notés <E> ;Ex : interface List<E> correspond aux séquences d’objets d’untype « E » quelconque.

2 Hiérarchie de Classes : plusieurs implantations p/chaque interface ;Ex : ArrayList<E> et LinkedList<E> sont des implantations deList<E>.


Infrastructure : interfaces + classes (extrait)

<E> : type générique E pour éléments Important : consulter la Javadoc pour toutesces collections !


Organisation de l’infrastructure

Les structures des données sont organisées en 2 hiérarchies indépendantesd’interfaces génériques + des classes concrètes qui les implantent.

2 hiérarchies d’interfaces

Hiérarchie « Collection »

Collections proprement dites. Racine : Collection<E>Objets membres « mis à plat ». Ex : listes, ensembles, piles ;

Hiérarchie « Map »

dictionnaires associatifs contenant des couples (clés, valeurs) ;Racine : Map<E>

contiennent des extensions (héritage) où les membres sont ordonnés ;


2 Hiérarchies d’interfaces (extrait)

héritage entre interfaces ⇒ interface « fille » plus riche (+ de méthodes)que son « ancêtre » ; apporte une organisation particulière aux objets dela collection + sens adapté pour les opérations.

généricité : utilisables avec tout type objet « E » (quelconque) ;

Iterable <E>

Map<K,V>Collection <E>

List<E> Queue <E> Set<E>SortedMap<K,V>

SortedSet<E>extends

types quelconques

<E> : type générique E pour les éléments d’une collectionVirginia Aponte (CNAM-Paris) NFA035 17 septembre 2021 7 / 46

Extrait : interfaces + classes implantantion (listes +files)« List » : séquences d’objets (de type <E>) ; chacun a une position.

« Files » : les opérations d’ajout et de retrait se font souvent sur lesextremités.

Iterable <E>

Collection <E>

List<E> Queue <E>

ArrayList<E> PriorityQueue<E>

LinkedList<E>

extends

implements

Interfaces

Classes

<E> : type générique E pour les élémentsVirginia Aponte (CNAM-Paris) NFA035 17 septembre 2021 8 / 46

L’interface Collection<E>

IdéeInterface la plus générale parmi les collections. Les membres d’unecollection sont « à plat » ET sans contrainte d’organisation.

chaque interface fille apporte un mode d’organisation

Opérations :

size, isEmpty, contains : taille, tester si vide, testerappartenance d’un objet.

add, remove : ajouter, enlever un objet.

iterator : fabrique un objet permettant d’accèder un à un aux objetsmembres de la collection.


Interface Collection<E> (extrait)

public interface Collection<E> extends Iterable<E> {int size();boolean isEmpty();boolean add(E o);boolean remove(Object o);boolean contains(Object o);Iterator<E> iterator(); // fabriquer un objet pour

// parcourir la collectionE[] toArray(E[] t);

les classes qui implantent cette interface⇒ possèdent ces méthodes ;

add, remove retournent true si l’opération a pu s’effectuer.


3 familles de Collection

Trois sous-hiérarchies selon le mode d’organisation des objets membres :

Séquences (List<E>) : les objets sont rangés séquentiellement, sontaccessibles par leur position, etc.

Exemples : classes LinkedList<E> et ArrayList<E>

Ensembles (Set<E>) : sans doublons ni position

Exemples : classes HashSet<E> et TreeSet<E> (ordonnés)

Files (Queue<E>) : les objets sont rangés séquentiellement avecopérations « d’entrée/sortie » de la file.

Exemple : classe PriorityQueue<E>


Interface List<E>

Hérite de Collection<E>

Correspond aux « séquences d’objets de type <E> » (listes) :

chaque objet a une position dans la séquence ;

nouvelles opérations pour les accès par position : E get(int),int indexOf(Objetct), add(i, E)

Nous étudiérons sont implantation : ArrayList<E>

public interface List<E> extends Collection<E> {boolean add(int i, E o);boolean remove(int i);int indexOf(Object o);...


Généricité


Définition

GénéricitéUn code (classes, méthodes) est écrit en termes d’un type quelconque,désigné par une lettre entourée des symboles <>.

<E> : signifie «n’importe quel type objet»

Exemple : classe ArrayList<E> . Son code est écrit pour un type objetquelconque E

utilisable pour n’importe quel E : new ArrayList<Compte>()⇒ Ici, E=Compte.


Exemple généricité : classe ArrayList<E>

public class ArrayList<E>implements List<E>, Collection<E>, Iterable<E> ...{

public boolean add(<E> el) {...}public E get(int i){...}

....}

E : type (quelconque) des éléments de la liste ;

implante plusieurs interfaces génériques ;

les méthodes ont des types génériques :

⇒ boolean add(<E> el)ajoute un élément de type E dans la liste ;


Une implantation de List : ArrayList


ArrayList

Implante List. Fonctionnement proche tableaux.

ArrayList<E>

classe générique de Java :les éléments doivent être de même type ;ce type peut être quelconque (objet) ;on doit juste préciser ce type à la déclaration.

fonctionne comme un tableau de taille automatiquement variable

les éléments ont une position,on peut y ajouter autant d’éléments qu’on veut,on peut les accéder/modifier selon leur position.


ArrayList : déclaration et création

éléments necéssairement de type objet (pas primitif) ;

préciser leur type à la déclaration, p.e., String :ArrayList<String>

on doit les créer avant utilisation via new,

ArrayList<String> maListe;maListe= new ArrayList<String>();

la liste crée est vide.

Important : on doit déclarer en début de fichier,import java.util.ArrayList;public class ...


ArrayList : utilisation

un ArrayList est un objet ;

les objets sont utilisés en leur appliquant des méthodes de laclasse à laquelle appartient l’objet ;

Exemple :

ArrayList<String> maListe;maListe= new ArrayList<String>();

On lui applique la méthode size() pour obtenir la taille de la liste :

int long= maListe.size();


Quelques méthodes de la classe ArrayList<T>

Elément de la liste de type T ⇒ ArrayList<T> :

int size() : fonction qui renvoie la longueur de la liste ;boolean isEmpty() : fonction qui teste si la liste est vide(renvoie true dans ce cas-là) ;

Les cases d’un ArrayList commencent à 0

T get(int i) : renvoie le contenu de la case numéro i. Le typede l’objet retourné est T.

add(T el) : ajoute l’élément el à la fin de la liste.


Exemple : ArrayList de comptes

Si Compte possède les méthodes :

donneSolde()

depot(double m)

retrait(double m)

Création d’une liste de comptes :

ArrayList<Compte> lc = new ArrayList<Compte>();Compte c1 = new Compte(); Compte c2 = new Compte();

lc.add(c1);lc.add(c2);


La somme des soldes

lc est un ArrayList de comptes ;

pour parcourir la liste : i< lc.size() ;

pour obtenir le compte de position i : lc.get(i) ;

pour obtenir le solde de ce compte : lc.get(i).donneSolde()

public static double sommeSoldes(ArrayList<Compte> lc){double s=0;for (int i= 0; i < lc.size(); i++) {

s= s + lc.get(i).donneSolde();}return s;

}


Autres méthodes

set(int i, T el) : remplace la valeur dans la case i par el.

remove(int i) supprime l’élément dans la case i ;

remove(Object el) supprime la première occurrence de el.Contenu des cases décalé ; longeur de la liste diminué de 1.

boolean contains(Object el) : renvoie vrai si la listecontient la valeur el.

int indexOf(Object el) : renvoie la position de el dans laliste, et -1 s’il n’y apparaît pas.

add(int i, T el) ajoute la valeur el dans la position i.


Parcours de collections : itérateurs et for each


Parcourir une collection

Toutes les collections possèdent 2 mécanismes de parcours de leurscomposantes :

boucle for-each : permet de visiter les éléments d’une collection.Inconvénient : impossible de retirer des composantes pendant leparcours (lève l’exception ConcurrentModificationException).

objet itérateur : permet de visiter tous les éléments d’une collection « enavançant ». Permet de retirer des éléments pendant le parcours.


Objest itérateurs

ItérateurObjet de type (interface) Iterator, permettant de « visiter » tous leséléments d’une collection. A la création, cet objet pointe juste avant lepremier objet à visiter de la collection. Cet objet possède 3 méthodes :

T next() : obtenir le « prochain » élément de la collection ;

boolean hasNext() : true s’il reste des éléments non encore« visités » ;

boolean remove() : enleve l’élément de la collection sur lequel onvient de faire « next ».

Toute collection fornit la méthodeIterator iterator();

permettant de fabriquer cet objet.


Parcourir une collection avec un itérateur

Au départ, une collection Collection c = ...

1 Fabriquer un itérateur sur les composantes de cIterator<T> it = c.iterator();

⇒ it pointe vers le prochain élément à visiter dans c

2 écrire une boucle qui s’exécute tant qu’il y a des composantes à visiter :while (it.hasNext()) { ...

3 dans la boucle :

it.next() ⇒ pour obtenir le prochain élément ;

it.remove() ⇒ si on veut supprimer le dernier élément obtenupar un appel à next();.


Exemple : extraire la sous-liste de comptes fermésMéthode d’extraction de la sous-liste de comptes livrets A fermés.

Argument : une collection quelconque ⇒ type Collection

on pourra lui passer n’importe quelle classe qui l’implante : ArrayList,Set, . . . .

public static ArrayList<CompteLivretA>extraitFermes(Collection<CompteLivretA> cmptes){

ArrayList<CompteLivretA> res = new ArrayList<CompteLivretA>();Iterator<CompteLivretA> iter = cmptes.iterator();while (iter.hasNext()){

CompteLivretA c = iter.next();if (!c.estOuvert())

res.add(c);}return res;

}


Boucle for each

Forme très générique de boucles for sur collections et tableaux :

for (T el : uneCol) {«appliquer actions sur» el;

}

« Pour chaque valeur el de type T dans uneCol appliquer actions. »

Syntaxe :

T (type des éléments) : el (nom valeur dans case) ;

uneCol nom variable tableau ou collection.

La boucle s’effectue sur une copie de chaque composante de la collection.


Itérerer avec for each sur une collection

Afficher tous les noms d’une collection. Fonctionne pour toute instance deCollection !

Collection<String> noms = new ArrayList<String>();...for (String n : noms) {

System.out.println(n);}

noms : nom variable collection.

String : type éléments,

n : nom valeur dans case,


Exemple : afficher une collection de comptesMéthode d’affichage des comptes livrets A d’une collection quelconque.

Argument : une collection quelconque ⇒ type Collection

on pourra lui passer n’importe quelle classe qui l’implante ;

Remarque : il faut re définir la méthode String toString() dans laclasse CompteLivretA. Autrement, son appel affichera les adressesdes comptes (définition par défaut)

Remarque 2 : on aurait pu utilise un itérateur !

public static void affiche(Collection<CompteLivretA> cmptes){for (CompteLivretA c: cmptes){

System.out.println(c.toString()); // redefinir// + CompteLivretA

}}


for each sert aussi sur des tableaux !

Employée aussi pour « voir » chaque case de tableau :

int [] tab = {1, 2, 3};// Additionnes ttes cases du tableauint somme = 0;for (int e : tab) {

somme = somme + e;;}System.out.println("Somme = "+ somme);

Affiche : Somme = 6

AttentionVariable e n’est pas une case du tableau, mais une copie de son contenu !


Pas de modification de collection/tableau

Attention : for eachne permet pas traverser + modifier le tableau/collection en même temps !

int [] tab = {1, 2, 3};for (int e : tab){

e = e*10; // Tentative de modification}System.out.println("Tableau apres:");for (int e : tab){

System.out.print(" "+ e);}

Tableau apres:1 2 3

⇒ Non modifié après la boucle !


L’interface Set


Structure des données « Ensemble »

Caractéristiques principales :

ordre des éléments indeterminé, sauf si c’est un ensemble trié ;

doublons non admis ;

pas d’élément « suivant » (comment le parcourir alors ?)

En pratique :

les structures des données sans doublons sont très utiles ! Ex :ensembles de noms de contacts, de comptes dans une banque, etc.

infrastructure Collections : interfaces Set et SortedSet, classesTreeSet, HashSet.


Extrait de l’interface Set

public interface Set<E> extends Collection <E> {boolean addAll(Collection<?> c);boolean remove(Object o);boolean contains(Object o);boolean removeAll(Collection<?> c);...

Opérations d’union, intersection :

addAll(c) : union de l’ensemble courant avec la collection c vuecomme un ensemble ;

retainAll(c) : intersection avec la collection c vue comme unensemble

retournent true si l’opération a pu s’effectuer ;


Implantations de « Set »

Deux implantations principales :

HashSet :

implante Set<E>basée sur des tables de hash ;ordre « non determiné » pour éléments ;la plus rapide.

TreeSet :

implante SortedSet<E>basée sur des arbres de recherche ;maintient l’invariant suivant : éléments ordonnées (par défaut, selonleur ordre « naturel »).


Extrait Interfaces + implantations (set+map)

Extrait hiérarchies pour les structures « ensembles » et « dictionnairesassociatifs » :

HashMap<K,V>

Map<K,V>

Collections <E>

HashSet<E>

TreeSet<E>

Set<E>

SortedMap<K,V>

SortedSet<E>

TreeMap<K,V>

extends

implements

Interfaces

Classes


Classe HashSet

Un exemple d’ensemble de chaînes :

// CreationHashSet<String> ens = new HashSet<String> ();// Tests, ajoutsboolean d = ens.contains("A"); // A dedans?System.out.println("contient A avant ajout? "+ d);ens.add("A"); // ajout Ad = ens.contains("A"); // A dedans?System.out.println("contient A apres ajout? "+ d);

Méthode add ⇒ indique si l’ajout a pu être effectue :

retourne true si élément était absent avant ajout (ajout effectué) ;

retourne false si élément est déjà présent (ajout non effectué) ;


HashSet : add (1)

boolean d = ens.contains("A"); // A dedans?System.out.println("contient A avant ajout? "+d);ens.add("A"); // ajout Ad = ens.contains("A"); // A dedans?System.out.println("contient A apres ajout? "+d);

Affichages :

contient A avant ajout? --> falsecontient A apres ajout? --> true


HashSet : add (2)

Ajout de B, C

boolean r = ens.add("B"); // 1er ajout BSystem.out.println("1er ajout B: "+ r);r = ens.add("B"); // 2eme ajout BSystem.out.println("2eme ajout B: "+ r);ens.add("C"); // Ajout C

Affichages :

1er ajout B: true2eme ajout B: false


Enlever des composantes d’une collection pendantson parcours


Modification pendant itération

Impossible modifier tableau/collection via variables de for each :

si tableau ⇒ pas de modification ;

si collection ⇒ lévée exceptionConcurrentModificationException


Modification collection pendant itérationTentons d’enlever les éléments qui commencent par A dans une collectionscNoms :

Collection cNoms = new ... // on y a mis des chaines

// Tentative modification sur cette collectionfor (String s: cNoms){

if (s.charAt(0)==’A’) cNoms.remove(s);}

Exception in thread "main"java.util.ConcurrentModificationException

Modification collection pendant itérationSeul moyen sûr de le faire : via un iterator


Modifier une collection avec itérateur

Enlever les mots qui commencent par A :

Iterator<String> ic = cNoms.iterator();while (ic.hasNext()) {

String element = ic.next();if (element.charAt(0) == ’A’) {

ic.remove();}

}System.out.println("Sans mots commencant par A: ");for (String s: cNoms){ // Ici: boucle for-each

System.out.println(s);}

Sans mots commencant par A:Loulou Lucie Julien Thomas Remy


Une autre écriture

Enlever les mots qui commencent par A :

for (Iterator<String> ic = cNoms.iterator(); ic.hasNext();) {String element = ic.next();if (element.charAt(0) == ’A’) {

ic.remove();}

}System.out.println("Union sans les A: ");for (String s: cNoms){ // Ici: boucle for-each

System.out.println(s);}

Union sans les A:Loulou Lucie Julien Thomas Remy


collections en java partie 1 - deptmedia.cnam.fr

Documents