13-Collections 2023 en Java Partie1

Les Collections
en Java
Préparé par : Larbi HASSOUNI

Qu'est ce qu'une collection(1)?
• Une collection est un simple objet qui regroupe un groupe d'objets.
• Chaque objet faisant partie de la collection est appelé élément de la collection.
• Il existe plusieurs types de collections. Chacun implémente un type particulier de
structure de données.
• Chaque type de collection gère ses éléments de sa propre manière, et utilise un
type de stockage donné.
• Le Framework des collections consiste en un ensemble d'interfaces, des classes
qui implémentent ces interfaces, et des classes utilitaires pour manipuler la
plupart des types de ces collections.
• Toutes les interfaces et classes du Framework collection sont génériques.
• Toutes les interfaces et classes collections sont stockées dans le package java.util
L. HASSOUNI 2
Qu’est ce qu’une collection(2)?
Une collection, parfois appelée conteneur, est simplement un objet qui
regroupe plusieurs éléments (objets) en une seule unité.
Les collections sont utilisées pour stocker, récupérer, manipuler et
communiquer des données agrégées.
En règle générale, ils représentent des éléments de données qui forment
un groupe naturel, comme une main de poker (une collection de cartes),
un dossier de courrier (une collection de lettres) ou un annuaire
téléphonique (une mise en correspondance de noms avec des numéros
de téléphone).
3
Qu’est ce que le framework Collections?
• Un framework de collections est une architecture unifiée pour représenter
et manipuler des collections. Tous les frameworks de collections
contiennent les éléments suivants :
• Interfaces: Ce sont des types de données abstraits qui représentent des
collections. Les interfaces permettent de manipuler les collections
indépendamment des détails de leur représentation. Dans les langages
orientés objet, les interfaces forment généralement une hiérarchie.
• Implémentations : Ce sont les implémentations concrètes des interfaces
de collection. Ce sont essentiellement des structures de données
réutilisables.
• Algoritmes : Ce sont les méthodes qui effectuent des calculs utiles, tels
que la recherche et le tri, sur des objets qui implémentent des interfaces
de collection.
Les algorithmes sont dits polymorphes : c'est-à-dire que la même méthode
peut être utilisée sur de nombreuses implémentations différentes de
l'interface de collection appropriée.
En substance, les algorithmes sont des fonctionnalités réutilisables.
L. HASSOUNI 4
Interfaces du FrameWork Collections
• Les interfaces de base du Framework encapsulent différents
types de collections, qui sont illustrés dans la figure qui suit.
• Ces interfaces permettent de manipuler des collections
indépendamment des détails de leur représentation.
• Les interfaces de base sont à la base du Framework
Collections et forment une hiérarchie.
L. HASSOUNI 5
Les interfaces de base du Framework collections
6
Hiérarchie des Collections
7
• Un Set est un type spécial de Collection, un SortedSet est un type
spécial de Set, et ainsi de suite.
• Notez également que la hiérarchie se compose de deux arbres

distincts — une Map n'est pas une véritable collection.
• Notez que toutes les interfaces de base des collections sont

génériques.
Par exemple, la déclaration de l'interface Collection est:
• public interface Collection<E>...
L. HASSOUNI 8
• La syntaxe <E> vous indique que l'interface est générique.
• Lorsque vous déclarez une instance de Collection, vous pouvez et
devez spécifier le type d'objet contenu dans la collection.
• La spécification du type permet au compilateur de vérifier (au
moment de la compilation) que le type d'objet que vous mettez dans
la collection est correct, réduisant ainsi les erreurs au moment de
l'exécution.
L. HASSOUNI 9
• Lorsque vous comprendrez comment utiliser ces interfaces, vous saurez
la plupart de ce qu'il y a à savoir sur le Framework Collections.
• Dans ce qui suit nous allons traiter des directives générales pour une
utilisation efficace des interfaces, y compris quand utiliser quelle
interface.
• Nous étudierons également les idiomes de programmation pour chaque
interface pour en tirer le meilleur parti.
L. HASSOUNI 10
• Pour que le nombre d'interfaces de base reste gérable, la plate-forme
Java ne fournit pas d'interfaces distinctes pour chaque variante de
chaque type de collection. (Ces variantes peuvent être immuable, de
taille fixe et d'ajout uniquement.)
• Au lieu de cela, les opérations de modification dans chaque interface
sont désignées facultatives — une implémentation donnée peut
choisir de ne pas prendre en charge toutes les opérations.
• Si une opération non prise en charge est invoquée, une collection lève
une exception qui est UnsupportedOperationException.
• Les implémentations sont chargées de documenter les opérations
facultatives qu'elles prennent en charge.
• Toutes les implémentations à usage général de la plate-forme Java
prennent en charge toutes les opérations facultatives.
L. HASSOUNI 11
• La liste suivante décrit les interfaces de base :
• Collection : la racine de la hiérarchie des collections.
• Une collection représente un groupe d'objets appelés ses
éléments.
• L'interface Collection est le plus grand diviseur commun que
toutes les collections implémentent et est utilisée pour faire
circuler des collections et les manipuler lorsqu'une généralité
maximale est souhaitée.
• Certains types de collections autorisent les éléments en double,
d'autres non. Certains sont ordonnés et d'autres non ordonnés.
• La plate-forme Java ne fournit aucune implémentation directe de
cette interface mais fournit des implémentations de sous-
interfaces plus spécifiques, telles que Set et List.
L. HASSOUNI 12
• Set :
• une collection qui ne peut pas contenir d'éléments en double.
• Cette interface modélise l'abstraction mathématique des

ensembles et permet de représenter des ensembles, tels que :
• Les cartes composant une main de poker,
• Les cours composant l'emploi du temps d'un étudiant,
• ou les processus s'exécutant sur une machine
L. HASSOUNI 13
• List:
• une collection ordonnée (parfois appelée séquence).
• Les listes peuvent contenir des éléments en double.
• L'utilisateur d'une liste a généralement un contrôle précis sur
l'endroit où chaque élément est inséré dans la liste et peut
accéder aux éléments par leur indice entier (position).
L. HASSOUNI 14
• Queue: (File d’attente)
• une collection utilisée pour contenir plusieurs éléments avant le traitement.
• Outre les opérations de base, une Queue fournit des opérations d'insertion,
d'extraction et d'inspection supplémentaires.
• Les files d'attente classent généralement, mais pas nécessairement, les éléments de
manière FIFO (premier entré, premier sorti).
• Parmi les exceptions figurent les files d'attente prioritaires, qui classent les éléments
en fonction d'un comparateur fourni ou de l'ordre naturel des éléments.
• Quel que soit l'ordre utilisé, la tête de file d'attente est l'élément qui serait supprimé
par un appel à remove ou à poll.
• Dans une file d'attente FIFO, tous les nouveaux éléments sont insérés en queue de
file d'attente.
• D'autres types de files d'attente peuvent utiliser des règles de placement différentes.
• Chaque implémentation de file d'attente doit spécifier ses propriétés de commande
L. HASSOUNI 15
• Deque:
• une collection utilisée pour contenir plusieurs éléments avant le
traitement.
• Outre les opérations de collecte de base, un Deque fournit des
opérations d'insertion, d'extraction et d'inspection
supplémentaires.
• Deque peut être utilisé à la fois comme FIFO (premier entré,
premier sorti) et LIFO (dernier entré, premier sorti).
• Dans un deque, tous les nouveaux éléments peuvent être insérés,
récupérés et supprimés aux deux extrémités
L. HASSOUNI 16
• Map:
• un objet qui mappe les clés aux valeurs.
• Une Map ne peut pas contenir de clés en double ;
• chaque clé peut correspondre à au plus une valeur.
• Si vous avez utilisé Hashtable, vous connaissez déjà les
bases de Map.
L. HASSOUNI 17
• Les deux dernières interfaces sont simplement des
versions triées de Set et Map :
• SortedSet:
• un ensemble qui conserve ses éléments dans l'ordre croissant.
• Plusieurs opérations supplémentaires sont prévues pour profiter de
la commande.
• Les ensembles triés sont utilisés pour les ensembles naturellement
ordonnés, tels que les listes de mots et les listes d'adhésion
• SortedMap:
• une Map qui conserve ses mappages dans l'ordre croissant des
clés.
• C'est l'analogue Map de SortedSet.
• Les Maps triées sont utilisées pour les collections naturellement
ordonnées de paires clé/valeur, telles que les dictionnaires et les
annuaires téléphoniques
L. HASSOUNI 18
• L'avantage de spécifier une structure de données par une interface
est de permettre plusieurs implémentations différentes d'une même
structure.
• Le Framework des collections fournit des classes qui implémentent
ces interfaces.
• Il est recommandé d'utiliser une interface pour déclarer un objet
collection plutôt que la classe qui implémente l'interface.
• Par exemple pour déclarer un objet collection liste, il est recommandé
d'utiliser :
List <String> noms = new ArrayList<>();
Plutôt que:
ArrayList<String> noms = new ArrayList<>();
L. HASSOUNI 19
L'interface <<Collection>>
• L'interface Collection est la racine du Framework des collections. Elle
définit une collection générique.
• Le Framework des collections ne fournit pas de classes qui
implémente l'interface Collection.
• L'interface Collection définit le type collection le plus générique et
peut être passé comme paramètre aux méthodes.
• L'interface Collection déclare un ensemble de méthodes qui sont
héritées par tous les autres interfaces collections.
L. HASSOUNI 20
<<interface>>
API Collection Iterable<T>
<<interface>>
Méthode de l'interface Iterable Collection<T>
public default void forEach(Consumer<? super T> action)

Performs the given action for each element of the Iterable until all
elements have been processed or the action throws an exception.
Iterator<T> iterator()
Returns an iterator over elements of type T.
default Spliterator<T> spliterator()
Creates a Spliterator over the elements described by this Iterable.
L. HASSOUNI 21
API Collection
• Les méthodes de l'interface Collection peuvent être réparties en les
opérations suivantes:
➢Opérations basiques
➢Opérations vrac
➢Opérations d'agregats
➢Opérations tableaux
➢Opérations de comparaison
Une classe qui implémente l'interface Collection doit lancer l'exception

UnsupportedOperationException (hérite de RunTimeException) pour les
méthodes optionnelles.
L. HASSOUNI 22
L. HASSOUNI 23
Méthodes pour opérations basiques
boolean add(E e)
Ensures that this collection contains the specified element (optional operation).
void clear()
Removes all of the elements from this collection (optional operation).
boolean contains(Object o)
Returns true if this collection contains the specified element.
boolean remove(Object o)
Removes a single instance of the specified element from this collection, if it is present (optional operation).
boolean isEmpty()
Returns true if this collection contains no elements.
int size()
Returns the number of elements in this collection.
L. HASSOUNI 24
package collectionbasicop;
import java.util.ArrayList;
import java.util.Collection;
public class OperationsBasiques {

public static void main(String[] args) {
Collection<String> noms = new ArrayList<>();
if(noms.isEmpty()){
System.out.println("Collection vide");
}else{
System.out.println("Collection non vide");
}
noms.add("Moha");
noms.add("Toto");
noms.add("Manolo");
noms.add("Moha");
System.out.println("Elements : " + noms + " Taille : " + noms.size());
L. HASSOUNI 25
noms.remove("Manolo");
if(noms.contains("Manolo")){
System.out.println("Manolo est contenu dans la liste");
}else{
System.out.println("Manolo n'est pas contenu dans la liste");
}
noms.remove("Moha");
noms.clear();
}
}
Résultats exécution:
Collectioon vide
Elements : [Moha, Toto, Manolo, Moha] Taille : 4
Elements : [Moha, Toto, Moha] Taille : 3
Manolo n'est pas contenu dans la liste
Elements : [Toto, Moha] Taille : 2
Elements : [] Taille : 0
L. HASSOUNI 26
public class OperationsBasiques {
Collection<String> noms = new ArrayList<>();
if(noms.isEmpty()){ System.out.println("Collectioon vide"); }
else{System.out.println("Collectioon non vide"); }
noms.add("Moha");
noms.add("Toto");
noms.add("Manolo");
noms.add("Moha");
noms.remove("Manolo");
if(noms.contains("Manolo")){ System.out.println("Manolo est contenu dans la liste"); }
else{System.out.println("Manolo n'est pas contenu dans la liste"); }
noms.remove("Moha");
noms.clear();
}
}
L. HASSOUNI 27
Méthodes pour opérations vrac
boolean addAll(Collection<? extends E> c)
Adds all of the elements in the specified collection to this collection (optional operation).
boolean retainAll(Collection<?> c)
Retains only the elements in this collection that are contained in the specified collection (optional operation).
boolean containsAll(Collection<?> c)
Returns true if this collection contains all of the elements in the specified collection.
boolean removeAll(Collection<?> c)
Removes all of this collection's elements that are also contained in the specified collection (optional operation).
default boolean removeIf(Predicate<? super E> filter)

Removes all of the elements of this collection that satisfy the given predicate.
L. HASSOUNI 28
public class OperationsVrac {

public static void main(String[] args){
Collection<String> sportifs = new ArrayList<>();
Collection<String> footballeurs = new ArrayList<>();
Collection<String> joueursTennis = new ArrayList<>();
sportifs.add("Aouita");
sportifs.add("Moutawakkil");
footballeurs.add("Zaki");
footballeurs.add("Bouderbala");
joueursTennis.add("El Aynaoui");
joueursTennis.add("Arazi");
joueursTennis.add("Alami");
L. HASSOUNI 29
System.out.println("Sportifs : " + sportifs + " NbSportifs : " + sportifs.size() );
sportifs.addAll(footballeurs);
if(sportifs.containsAll(footballeurs)){
System.out.println("Les footballeurs sont inclus dans la liste des sportifs");
}
sportifs.retainAll(footballeurs);
sportifs.retainAll(joueursTennis);
sportifs.addAll(joueursTennis);
sportifs.removeAll(footballeurs);
sportifs.removeIf((String e)->{return e.length()<6;});

}} L. HASSOUNI 30
Exécution
Sportifs : [Aouita, Moutawakkil] NbSportifs : 2
Sportifs : [Aouita, Moutawakkil, Zaki, Bouderbala] NbSportifs : 4
Les ffotballeurs sont inclus dans la liste des sportifs
Sportifs : [Zaki, Bouderbala] NbSportifs : 2
Sportifs : [] NbSportifs : 0
Sportifs : [Zaki, Bouderbala, El Aynaoui, Arazi, Alami] NbSportifs : 5
Sportifs : [El Aynaoui, Arazi, Alami] NbSportifs : 3
Sportifs : [El Aynaoui] NbSportifs : 1
L. HASSOUNI 31
public class OperationsVrac {
Collection<String> sportifs = new ArrayList<String>();
Collection<String> footballeurs = new ArrayList<>();
Collection<String> joueursTennis = new ArrayList<String>();
sportifs.add("Moutawakkil");
footballeurs.add("Zaki");
footballeurs.add("Bouderbala");
joueursTennis.add("Alami");
if(sportifs.containsAll(footballeurs)){
System.out.println("Les ffotballeurs sont inclus dans la liste des sportifs");
}
sportifs.retainAll(footballeurs);
sportifs.retainAll(joueursTennis);
sportifs.addAll(joueursTennis);
sportifs.removeAll(footballeurs);
sportifs.removeIf((String e)->{return e.length()<6;});
}}
L. HASSOUNI 32
Méthodes pour opérations de comparaison
boolean equals(Object o)
Compares the specified object with this collection for equality.
int hashCode()
Returns the hash code value for this collection.
public class OperationsComparaison {
Collection <String> joueursTennis = new ArrayList<>();
sportifs.add("El Aynaoui");
sportifs.add("Arazi");
sportifs.add("Alami");
L. HASSOUNI 33
if(sportifs.equals(joueursTennis)){
System.out.println("sportifs = joueursTennis");
}else{
System.out.println("sportifs # joueursTennis");
} Exécution
joueursTennis.add("Alami"); sportifs # joueursTennis
if(sportifs.equals(joueursTennis)){ sportifs = joueursTennis
System.out.println("sportifs = joueursTennis"); 189160881
}else{ 189160881
System.out.println("sportifs # joueursTennis"); -1416950800
}
System.out.println(sportifs.hashCode());
System.out.println(joueursTennis.hashCode());
int tothc = 0;
for(String e : sportifs){
tothc += e.hashCode();
}
System.out.println(tothc);
}
}
L. HASSOUNI 34
package collectionbasicop; Exécution
import java.util.ArrayList; sportifs # joueursTennis
import java.util.Collection; sportifs # joueursTennis
public class OperationsComparaison2 { -1183176409
public static void main(String[] args){ -1874243739
Collection<StringBuilder> sportifs = new ArrayList<>(); -80390400
Collection <StringBuilder> joueursTennis = new ArrayList<>();
sportifs.add(new StringBuilder("El Aynaoui"));
sportifs.add(new StringBuilder("Arazi"));
sportifs.add(new StringBuilder("Alami"));
joueursTennis.add(new StringBuilder("El Aynaoui"));
joueursTennis.add(new StringBuilder("Arazi"));
if(sportifs.equals(joueursTennis)){System.out.println("sportifs = joueursTennis");}
else{System.out.println("sportifs # joueursTennis");}
joueursTennis.add(new StringBuilder("Alami"));
if(sportifs.equals(joueursTennis)){System.out.println("sportifs = joueursTennis");}
else{System.out.println("sportifs # joueursTennis");}
System.out.println(sportifs.hashCode());
System.out.println(joueursTennis.hashCode());
int tothc = 0;
for(StringBuilder e : sportifs){tothc += e.hashCode();}
System.out.println(tothc);
}}
L. HASSOUNI 35
Méthodes pour opérations tableaux
Object[] toArray()
Returns an array containing all of the elements in this collection.
<T> T[] toArray(T[] a)
Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the
specified array.
L. HASSOUNI 36
Exécution
package collectionbasicop; El Aynaoui
import java.util.ArrayList; Arazi
import java.util.Collection; Alami
public class OperationsToArray { ================
public static void main(String[] args){ El Aynaoui
Collection<String> sportifs = new ArrayList<>(); Arazi
sportifs.add("El Aynaoui"); Alami
sportifs.add("Arazi");
sportifs.add("Alami");
Object[] objectArraySportifs = sportifs.toArray();

for(Object e : objectArraySportifs){System.out.println(e);}
System.out.println("==================================");
String[] stringArraySportifs = sportifs.toArray(new String[sportifs.size()]);
for(String e : stringArraySportifs){System.out.println(e);}
}
}
L. HASSOUNI 37
Méthodes pour opérations d'agrégats
default Stream<E> stream()
Returns a sequential Stream with this collection as its source.

default Stream<E> parallelStream()
Returns a possibly parallel Stream with this collection as its source.
Voir cours sur Java I/O
L. HASSOUNI 38
Méthodes pour parcourir (ou travaverser) une collection
Iterator<E> iterator()
Returns an iterator over the elements in this collection.
default Spliterator<E> spliterator()

Creates a Spliterator over the elements in this collection.
Pour parcourir une collection d'objets on peut procéder de

l'une des façons suivantes:
• Utiliser un Iterator
• Utiliser la boucle for-each
• Utiliser la méthode forEach().
L. HASSOUNI 39
Utilisation d'un Iterator
API Iterator
default void forEachRemaining(Consumer<? super E> action)
Performs the given action for each remaining element until all elements have been processed or the action throws an
exception.
boolean hasNext()
Returns true if the iteration has more elements.
E next()
Returns the next element in the iteration.
default void remove()

Removes from the underlying collection the last element returned by this iterator (optional operation).
L. HASSOUNI 40
• Une collection possède la méthode Iterator<E> iterator() qui lui
permet d'obtenir un objet Iterator pour parcourir tous les éléments de
la dite collection.
• Un objet Iterator peut exécuter les méthodes de l'interface Iterator.
• Ces méthodes, comme le montre le tableau API Iterator, sont :
• hasNext() : teste s'il y a un élément qui n'a pas été accédé.
• next() : retourne l'élément suivant de la collection. Nous devons toujours
exécuter next() après le succès d'un hasNext(), sinon next() lance l'exception
NoSuchElementException.
• Remove() : supprime l'élément de la liste qui vient d'être retourné par next().
Remove() doit être appelé une seule fois pour chaque appel de next().
Si la méthode remove() est appellée plus d'une fois pour un appel de next(), ou
avant le premier appel de next(), elle lance l'exception IllegalStateException.
Le support de la methode remove() est optionnel. Remove() peut lancer
l'exception UnsupportedOperationException.
L. HASSOUNI 41
Parcours d'une collection : Iterator , hasNext() et next()
Exécution
Aouita
import java.util.ArrayList; Guerrouj
import java.util.Collection; Bidouane
import java.util.Iterator;
public class OperationsIterator {

sportifs.add("Guerrouj");
sportifs.add("Bidouane");
Iterator<String> sportifsIterator = sportifs.iterator();

while(sportifsIterator.hasNext()){
String nom = sportifsIterator.next();
System.out.println(nom);
}
}
} L. HASSOUNI 42
L. HASSOUNI 43
Suppression d'éléments d'une collection : Iterator, remove()
package collectioniterator;
import java.util.ArrayList; Exécution
import java.util.Collection; Aouita
import java.util.Iterator; Guerrouj
public class CollectionIteratorRemove { Bidouane
public static void main(String[] args){ []
• Remarque :
sportifs.add("Guerrouj"); • Un Iterator est un objet à
sportifs.add("Bidouane"); une seule utilisation. Il ne
peut pas être réinitialisé
Iterator<String> sportifsIterator = sportifs.iterator(); pour parcourir la collection
while(sportifsIterator.hasNext()){ une nouvelle fois.
String nom = sportifsIterator.next(); • Pour parcourir la collection
System.out.println(nom); une nouvelle fois, il faut
sportifsIterator.remove(); créer un nouveau Iterator
} avec la méthode iterator()
System.out.println(sportifs); de l'objet collection.
}
}
L. HASSOUNI 44
Application d'une action sur chaque élément d'une collection
méthode forEachRemaining()
• La méthode forEachRemaining() de l'objet Iterator permet
d'appliquer une action sur chaque élément de la collection qui n'a pas
encore accédé.
• L'action est spécifiée comme un objet "instance" de l'interface
fonctionnel Consumer.
• Il est possible de passer une lambda expression comme argument de
la méthode forEachRemaining().
L. HASSOUNI 45
Parcours d'une collection avec la boucle for-each
package collectioniterator; Aouita
import java.util.ArrayList; Guerrouj
import java.util.Collection; Bidouane
public class CollectionForEachLoop { Remarque:

public static void main(String[] args){ La boucle for-each a quelques
Collection<String> sportifs = new
limitations:
ArrayList<>();
▪ On ne peut pas commencer à
sportifs.add("Aouita"); partir du milieu de la collection
sportifs.add("Guerrouj"); ▪ On ne peut pas supprimer un
sportifs.add("Bidouane"); élément de la collection.
L'exécution de la méthode
for (String elt : sportifs){ remove() dans une boucle for-
System.out.println(elt); each lance l'exception
} ConcurrentModificationException
}
}
L. HASSOUNI 46
Exception ConcurrentModificationException
java.util.ConcurrentModificationException
Aouita
Exécution
import java.util.ConcurrentModificationException;
public class CollectionForEachLoopRemove {
try{
for (String elt : sportifs){
System.out.println(elt);
sportifs.remove(elt);
}
}catch(ConcurrentModificationException e){
System.out.println(e);
}
}
}
L. HASSOUNI 47
iterator.forEachRemaining(action)
Exécution
import java.util.Collection; Aouita
import java.util.Iterator; Guerrouj
Bidouane
public class CollectionIteratorForEachRemaining {

sportifsIterator.forEachRemaining(System.out::println);
//sportifsIterator.forEachRemaining((String e)->System.out.println(e));
}
L. HASSOUNI 48
}
API de l'interface fonctionnel Consumer<T>
@FunctionalInterface
public interface Consumer<T>
Représente une opération qui accepte un seul argument et ne retourne pas de résultat.
Comme tout interface fonctionnel, il peut être cible d'une affectation par une lambda expression
ou une référence de méthode "method reference".
API interface Consumer<T>

void accept(T t)
Performs this operation on the given argument.
default Consumer<T> andThen(Consumer<? super T> after)

Returns a composed Consumer that performs, in sequence, this operation followed by the after operation.
L. HASSOUNI 49
import java.util.function.Consumer;
public class ConsumerDemo1 {
Consumer<String> consumer = (s) -> System.out.println(s);
Consumer<String> consumerString = (s) -> System.out.println(s.toUpperCase());
Consumer<Integer> intConsumer = (i) -> System.out.println(5*i);
// accept() - Performs this operation on the given argument.

/********************************************************/
consumer.accept("Bonjour Tout Le monde");
consumerString.accept("Plus haute Priorite");
intConsumer.accept(4);
}
}
L. HASSOUNI 50
import java.util.function.Consumer;
public class ConsumerDemo2 {
Consumer<Integer> c1 = (i) -> System.out.println(5*i);

Consumer<Integer> c2 = (i) -> System.out.println(5+i);
/* andThen(Consumer<? super T> after) - Returns a composed Consumer that performs,

in sequence, this operation followed by the after operation.*/
/********************************************************/
c1.andThen(c2).accept(4); // 20, 9
System.out.println("");
c2.andThen(c1).accept(5); //10, 25
System.out.println("");
c1.andThen(i -> System.out.println(3*i)).accept(4); // 20, 12
}
}
L. HASSOUNI 51
iterator.forEachRemaining(action)
import java.util.Collection; Exécution
Elt :Aouita Long : 6
public class CollectionIteratorForEachRemaining2 { Elt :Guerrouj Long : 8
public static void main(String[] args){ Elt :Bidouane Long : 8

sportifsIterator.forEachRemaining((String e)->
{System.out.println("Elt :" + e + "\tLong : "+e.length());});
}
}
L. HASSOUNI 52
Méthode forEach(Consumer action) de l'interface Iterable
L'interface Iterable contient une nouvelle méthode forEach(Consumer

action) qui permet de parcourir une collection tout en appliquant une
action sur chaque élément.
La méthode forEach() est disponible dans chaque type de collection qui
hérite de l'interface Collection.
L. HASSOUNI 53
public class CollectionForEach {

sportifs.forEach(System.out::println);
System.out.println("==============================");
sportifs.forEach((String e)->{System.out.println("Elt :" + e +
"\tLong : "+e.length());});
}
}
L. HASSOUNI 54
<<interface>>
Iterable<T>
Collection List
<<interface>>
• Une Liste est une collection non ordonnée d'objets Collection<T>
définie par l'interface List du framework Collection.
• Une liste peut avoir des éléments duppliqués. <<interface>>
Elle peut aussi stocker plusieurs valeurs null. List<T>
• L'interface List hérite de l'interface Collection et ajoute

de nouvelle méthodes pour permettre l'accès aux
éléments en utilisant un indice.
• Il est possible d'ajouter un élément à la fin d'une liste ou
à n'importe quelle position spécifiée par un indice.
• L'indice du 1er element d'une liste a la valeur zéro.
L. HASSOUNI 55
56
L. HASSOUNI 57
58
59
Méthodes spécifiques à une liste(1)
void add(int index, E element)
Inserts the specified element at the specified position in this list (optional operation).
boolean addAll(int index, Collection<? extends E> c)

Inserts all of the elements in the specified collection into this list at the specified position (optional
operation).
E get(int index)
Returns the element at the specified position in this list.
int indexOf(Object o)
Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain
the element.
int lastIndexOf(Object o)
Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain
the element.
L. HASSOUNI 60
Méthodes spécifique à une liste(2)
ListIterator<E> listIterator()
Returns a list iterator over the elements in this list (in proper sequence).
ListIterator<E> listIterator(int index)

Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
E remove(int index)
Removes the element at the specified position in this list (optional operation).
boolean removeAll(Collection<?> c)
Removes from this list all of its elements that are contained in the specified collection (optional operation).
E set(int index, E element)

Replaces the element at the specified position in this list with the specified element (optional operation).
List<E> subList(int fromIndex, int toIndex)

Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.
L. HASSOUNI 61
Méthodes spécifique à une liste(3)
default void replaceAll(UnaryOperator<E> operator)
Replaces each element of this list with the result of applying the operator to that element.
default void sort(Comparator<? super E> c)

Sorts this list according to the order induced by the specified Comparator.
L. HASSOUNI 62
ArrayList vs LinkedList
• ArrayList et LinkedList sont deux classes du Framework Collection qui implémentent
l'interface List.
• Une ArrayList est stokée dans un tableau dynamique.
• Une LinkedList est stockée sous forme de liste chaînée.
• Une ArrayList offre de meilleures performances lorsqu'on accède fréquemment aux
éléments de la liste. L'accès aux éléments se fait plus rapidément puisqu'une ArrayList
est sauvegardée dans un tableau.
• L'ajout et la suppression d'un élément d'une ArrayList se fait plus lentement à moins que
l'opération ne s'effectue à la fin de la liste, ceci parce qu'une ArrayList doit effectuer une
copie de tableau interne pour garder les éléments en séquence.
• Une LinkedList offre de meilleures performances qu'une ArrayList pour les opérations
d'ajout et de suppression à partir du milieu de la liste. Cependant, une LinkedList est plus
lente pour accéder aux éléments à moins que ça se passe en tête de la liste.
L. HASSOUNI 63
package ListExemples;
import java.util.List;
public class ListExemple01 {
List<String> langages = new ArrayList<>();
langages.add("C");
langages.add("C++");
langages.add("Java");
System.out.println("Langages: " + langages);
int nbElt = langages.size();

System.out.println("Nb Elts: " + nbElt);
for (int i = 0; i < nbElt; i++) {

String element = langages.get(i);
System.out.println("Index=" + i + ", Element=" + element);
}
L. HASSOUNI 64
List<String> subList = langages.subList(1, 2);
System.out.println(subList);
langages.remove("Java");
System.out.println("Langages : " + langages);
langages.add(0, "Java");
System.out.println("Langages : " + langages);
List<String>langWeb = new ArrayList<>();

langWeb.add("HTML");
langWeb.add(1, "CSS");
langWeb.add("JavaScript");
Exécution
langages.addAll(2, langWeb); Langages: [C, C++, Java]
System.out.println("LangagesWeb : " + langWeb); Nb Elts: 3
System.out.println("Langages : " + langages); Index=0, Element=C
Index=1, Element=C++
} Index=2, Element=Java
} [C++]
Langages : [C, C++]
Langages : [Java, C, C++]
LangagesWeb : [HTML, CSS, JavaScript]
Langages : [Java, C, HTML, CSS, JavaScript, C++]
L. HASSOUNI 65
<<interface>>
Parcours d'une liste avec ListIterator Iterator<T>
• L'interface List offre une méthode listIterator() qui permet

d'obtenir un Objet "instance" de l'interface ListIterator qui offre <<interface>>
ListIterator<T>
plus de possibilité que Iterator pour parcourir une liste.
ListIterator hérite de Iterator.
• Un ListIterator peut parcourir la liste dans les deux directions du
premier au dernier élément, ou du dernier au premier élément.
• La méthode next() avance d'un élément vers l'avant, et la
méthode previous() recule d'un élément vers l'arrière.
• Si vous utilisez next() suivi de previous(), l'iterator reste à la
même position.
ListIterator<String> iteratorGlobal = list.listIterator();

ListIterator<String> iteratorPartiel = list.listIterator(5);
L. HASSOUNI 66
API ListIterator : méthodes ajoutées dans ListIterator
void add(E e)
Inserts the specified element into the list (optional operation).
boolean hasPrevious()
Returns true if this list iterator has more elements when traversing the list in the reverse direction.
int nextIndex()
Returns the index of the element that would be returned by a subsequent call to next().
E previous()
Returns the previous element in the list and moves the cursor position backwards.
int previousIndex()
Returns the index of the element that would be returned by a subsequent call to previous().
Void set(E e)
Replaces the last element returned by next() or previous() with the specified element (optional operation).
L. HASSOUNI 67
Parcours d'une liste dans les deux directions avec ListIterator
package ListExemples;
import java.util.List;
import java.util.ListIterator;
public class ListListIterator {
List<String> langagesFonctionnels = new ArrayList<>();
langagesFonctionnels.add("Lisp");
langagesFonctionnels.add("Prolog");
langagesFonctionnels.add("Clojure");
langagesFonctionnels.add("Haskel");
System.out.println("Langages: " + langagesFonctionnels);
ListIterator<String> iteratorGlobal = langagesFonctionnels.listIterator();
System.out.println("==Parcourir la liste en avant==");

while (iteratorGlobal.hasNext()) {
int index = iteratorGlobal.nextIndex();
String element = iteratorGlobal.next();
System.out.println("Index=" + index + ", Element=" + element);
}
L. HASSOUNI 68
System.out.println("\n==Parcourir la liste en arière==");
while (iteratorGlobal.hasPrevious()) {
int index = iteratorGlobal.previousIndex();
String element = iteratorGlobal.previous();
System.out.println("Index=" + index + ", Element=" + element);
}
}
}
Langages: [Lisp, Prolog, Clojure, Haskel]

Exécution ==Parcourir la liste en avant==
Index=0, Element=Lisp
Index=1, Element=Prolog
Index=2, Element=Clojure
Index=3, Element=Haskel
==Parcourir la liste en arière==

Index=3, Element=Haskel
Index=2, Element=Clojure
Index=1, Element=Prolog
Index=0, Element=Lisp
L. HASSOUNI 69

13-Collections 2023 en Java Partie1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

13-Collections 2023 en Java Partie1

Transféré par

Droits d'auteur :

Formats disponibles

Les Collections

Préparé par : Larbi HASSOUNI

• Notez également que la hiérarchie se compose de deux arbres

• Notez que toutes les interfaces de base des collections sont

• Lorsque vous déclarez une instance de Collection, vous pouvez et

devez spécifier le type d'objet contenu dans la collection.

• La spécification du type permet au compilateur de vérifier (au

moment de la compilation) que le type d'objet que vous mettez dans

la collection est correct, réduisant ainsi les erreurs au moment de

la plupart de ce qu'il y a à savoir sur le Framework Collections.

utilisation efficace des interfaces, y compris quand utiliser quelle

• Nous étudierons également les idiomes de programmation pour chaque

interface pour en tirer le meilleur parti.

• une collection qui ne peut pas contenir d'éléments en double.

• Cette interface modélise l'abstraction mathématique des

• Les cours composant l'emploi du temps d'un étudiant,

• ou les processus s'exécutant sur une machine

• une collection ordonnée (parfois appelée séquence).

• Les listes peuvent contenir des éléments en double.

• L'utilisateur d'une liste a généralement un contrôle précis sur

l'endroit où chaque élément est inséré dans la liste et peut

accéder aux éléments par leur indice entier (position).

• un objet qui mappe les clés aux valeurs.

• Une Map ne peut pas contenir de clés en double ;

• chaque clé peut correspondre à au plus une valeur.

• Si vous avez utilisé Hashtable, vous connaissez déjà les

API Collection Iterable<T>

public default void forEach(Consumer<? super T> action)

Une classe qui implémente l'interface Collection doit lancer l'exception

public class OperationsBasiques {

default boolean removeIf(Predicate<? super E> filter)

public class OperationsVrac {

Collection<String> sportifs = new ArrayList<>();

Collection<String> footballeurs = new ArrayList<>();

Collection<String> joueursTennis = new ArrayList<>();

sportifs.removeIf((String e)->{return e.length()<6;});

Object[] objectArraySportifs = sportifs.toArray();

Returns a sequential Stream with this collection as its source.

Voir cours sur Java I/O

default Spliterator<E> spliterator()

Pour parcourir une collection d'objets on peut procéder de

Returns the next element in the iteration.

default void remove()

public class OperationsIterator {

Iterator<String> sportifsIterator = sportifs.iterator();

public class CollectionForEachLoop { Remarque:

Iterator<String> sportifsIterator = sportifs.iterator();

API interface Consumer<T>

default Consumer<T> andThen(Consumer<? super T> after)

public static void main(String[] args) {

Consumer<String> consumer = (s) -> System.out.println(s);

Consumer<String> consumerString = (s) -> System.out.println(s.toUpperCase());

Consumer<Integer> intConsumer = (i) -> System.out.println(5*i);

// accept() - Performs this operation on the given argument.

Consumer<Integer> c1 = (i) -> System.out.println(5*i);

/* andThen(Consumer<? super T> after) - Returns a composed Consumer that performs,

Iterator<String> sportifsIterator = sportifs.iterator();

L'interface Iterable contient une nouvelle méthode forEach(Consumer

public class CollectionForEach {

• L'interface List hérite de l'interface Collection et ajoute

boolean addAll(int index, Collection<? extends E> c)

Returns the element at the specified position in this list.

ListIterator<E> listIterator(int index)