Mathieu Grenon et des professeurs d’informatique 420-202-RE

Sommaire
Structures de données dynamiques ....................................................................................................................................... 2
Listes ....................................................................................................................................................................................... 3
Caractéristiques communes entre un tableau et une liste ............................................................................................. 3
Différences entre un tableau et une liste ....................................................................................................................... 3
Boucler sur une liste............................................................................................................................................................ 5
Comment parcourir et afficher une liste avec un for ? ................................................................................................. 6
Et avec un for each ? ................................................................................................................................................... 6
ArrayList vs tableaux : quoi choisir ? ......................................................................................................................... 6
Piles ......................................................................................................................................................................................... 7
Pile → LIFO (Last In, First Out) ............................................................................................................................................ 8
Stack (Les piles en Java) ...................................................................................................................................................... 9
Files (FIFO → First In, First Out) ............................................................................................................................................ 11
Files (FIFO → First In, First Out) ........................................................................................................................................ 12
LinkedBlockingQueue (Les files en Java) .................................................................................................................... 13
Comment choisir la structure à utiliser ? .............................................................................................................................. 14
.toString() ...................................................................................................................................................................... 16
Exemple pour une classe Cercle qu’on aurait écrit:...................................................................................................... 17
Attention : ..................................................................................................................................................................... 17

1
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Structures de données dynamiques

Les tableaux nous permettent de stocker des données du même type, mais ils sont restrictifs → taille fixe.

Le package java.util inclut plusieurs classes pour traiter des ensembles de données de taille variable (« collections »)
→ structures dynamiques.

 Les structures que nous verrons en classe sont les piles, les files et les listes
(il y en a d'autres).

 Ce sont des structures génériques – servent à stocker des objets de n’importe quel type (String… Voiture…
Personne… Bijou… )

2
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Listes
La liste est simple à comprendre et très flexible. Elle permet (souvent) de remplacer avantageusement les tableaux en
Java.

Caractéristiques communes entre un tableau et une liste

Liste Tableau
Les éléments sont placés séquentiellement Les éléments sont placés séquentiellement
On peut accéder à n’importe quel élément à l’aide de sa On peut accéder à n’importe quel élément à l’aide de sa
position dans la liste. position dans le tableau.
Différences entre un tableau et une liste

Liste Tableau
La liste a une taille variable, qui peut changer en cours Le tableau a une taille fixe, connue d’avance.
d’exécution.
Enlever un élément au centre d’une liste ne crée pas de Enlever un élément au centre du tableau crée un trou dans
trou. le tableau.
Je peux insérer un nouvel élément entre deux éléments Je ne peux pas insérer un élément entre deux éléments
existants. existants (à moins de le programmer moi-même, ce qui
n’est vraiment pas idéal).

Une List en Java est déclarée comme interface. Sans rentrer dans les détails (c’est de la matière qui sera abordée en 3e
session), il faut juste se rappeler qu’à l’instar des classes abstraites, on ne peut pas instancier List.

En Java, les listes sont implantées dans les classes :

- ArrayList  Liste à privilégier dans le cours

- LinkedList

On a dit que les listes servent souvent à remplacer les tableaux. Voici comment on représente graphiquement un
tableau et une liste qui contiendrait les mêmes Integer :

Exemple d’un tableau et d’un ArrayList

Tableau de taille 5 qui contient chacun des entiers suivants les uns à la suite des autres :

66 42 1 -7 33

ArrayList de taille non significative qui contient chacun des entiers suivants les uns à la suite des autres :

66 → 42 → 1 → -7 → 33

3
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Opération sur ArrayList Description Explication

liste.add(element) Ajouter un nouvel élément à la fin Ajouter 33 à la liste
[66]→ [42]→ [1]→ [-7]
va donner
[66]→ [42]→ [1]→ [-7] → [33]
liste.add(index,element) Ajouter un nouvel élément à la position index Ajouter 33 à la position 2
[66]→ [42]→ [1]→ [-7]
va donner
[66]→ [42]→[33]→ [1]→ [-7]
liste.get(index) Renvoie l’élément à la position index (sans l’enlever de la Demander l’élément à l’index 3
liste) [66]→ [42]→ [1]→ [-7]
va retourner
-7
liste.remove(index) Renvoie et retire l’élément à la position index spécifiée Enlever l’élément à l’index 0 de la
liste
[66]→ [42]→ [1]→ [-7]
va donner
[42]→ [1]→ [-7]
liste.remove(element) Renvoie et retire element de la liste, peu importe où il se Enlever l’élément [42] de la liste
trouve. [66]→ [42]→ [1]→ [-7]
va donner
[66]→ [1]→ [-7]
liste.set(index,element) Remplacer l’élément à la position index l’élément Remplacer l’élément à l’index 2 par
element. [123]
[66]→ [42]→ [1]→ [-7]
va donner
[66]→ [42]→ [123]→ [-7]
liste.clear() Efface tous les éléments de la liste liste.size() == 0
liste.indexOf(element) Renvoie la position de element s’il existe dans la liste (-1 s’il Demande l’index de l’élément [1]
n’existe pas) [66]→ [42]→ [1]→ [-7]
va retourner
2

Demande l’index de l’élément

[713705]
[66]→ [42]→ [1]→ [-7]
va retourner
-1
liste.contains(element) Renvoie true si l’élément existe dans la liste, false sinon Demander si la liste contient
l’élément [42]
[66]→ [42]→ [1]→ [-7]
va donner
true
liste.size() Renvoie la taille de la liste Demander la taille de la liste
[66]→ [42]→ [1]→ [-7]
va donner
4

4
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Exemple d’utilisation d’un ArrayList

public static void main(String[] args) {
ArrayList<String> liste = new ArrayList<>();
liste.add("Bleu");
liste.add("Rouge");
liste.add("Vert");
liste.add("Jaune");

System.out.println(liste.get(1)); // Résultat?
liste.remove(2);
System.out.println(liste.get(2)); // Résultat?
liste.add("Rose");
System.out.println(liste.indexOf("Bleu")); // Résultat?
System.out.println(liste.size()); // Résultat?
}

Réponses :
Rouge
Jaune
0
4

Remarquez qu’on indique le type de données de l’ArrayList à l’aide de crochets <>. Ainsi il n’est pas possible
d’insérer des éléments d’autres types dans cette liste, sauf s’il y a une relation d’héritage (si le type de la superclasse est
utilisé à la création de la liste, on peut y insérer des objets créés à l’aide d’une de ses sous-classes.)

Exemple de déclaration de listes

ArrayList<String> listeStrings = new ArrayList<>();
ArrayList<Integer> listeEntiers = new ArrayList<>();
ArrayList<Voiture> listeVoitures = new ArrayList<>();
ArrayList<Pokemon> listePokemon = new ArrayList<>();

On bloque ainsi les mauvaises entrées.

Boucler sur une liste

Une liste ressemble en beaucoup de points à un tableau.

5
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Comment parcourir et afficher une liste avec un for ?

for (int indice = 0; indice < liste.size(); indice++) {

System.out.println(indice + ": " + liste.get(indice));
}

Et avec un for each ?

for (String chaineCourante : liste) {

System.out.println(chaineCourante);
}

Exemple
Afficher tous les éléments d’une liste pendant qu’on la vide :

while (!liste.isEmpty()) {
System.out.println("Élément enlevé:" + liste.remove(0));
}

Évidemment, si on n’a pas besoin d’afficher chaque élément, ceci est plus facile et rapide :

liste.clear();

ArrayList vs tableaux : quoi choisir ?

Lorsque vous ne connaissez pas d'avance le nombre d'éléments à stocker en mémoire, ou que le nombre d'éléments
peut être variable lors de l'exécution d'un programme donné, il est souvent préférable d'utiliser une liste plutôt qu'un
tableau.

6
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Piles
C'est une "liste" qui suit une logique particulière dans son utilisation. Nous allons débuter l'explication par un exemple
simple :

Histoire vécue d'un plongeur dans une pizzeria de quartier un certain soir d'automne de pleine lune
C'était un soir de pleine lune, un certain samedi soir d'automne. Une belle soirée chaude, une des dernières de l'année
probablement avant le froid inévitable de l'hiver qui allait frapper à nos portes. Tout le monde en profitait, dans les
restos, dans les bars, dans les salles de bingo, vraiment tout le monde savourait les derniers instants qui ne sauraient
durer.

Tout le monde?

Et bien non. Un jeune homme, musclé et ténébreux, travaillait dans une petite pizzeria
de quartier, et maugréait devant sa pile de vaisselle en hurlant de désespoir. Et alors
qu'il voyait sa pile d'assiettes baisser à force de frotter et de frotter, on lui apportait
toujours de nouvelles assiettes à laver. Et encore des nouvelles. Et d'autres encore...
Mais quand cela va-t-il finir ??

Et la morale de cette histoire?

Il n'y en a pas. Mais s'il y en avait une, elle serait certainement songée et pertinente.

7
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Pile → LIFO (Last In, First Out)

Imaginez que vous voulez modéliser le problème des assiettes dans une petite pizzeria de quartier (mais pourquoi pas
?). On aurait une classe Assiette, avec plein d'instances de cette classe Assiette pour représenter chacune des
assiettes:

Stack<Assiette> pileAssiette = new Stack(); // Une pile

for (int i = 0; i < 1000; i++){

Assiette assiette = new Assiette();

pileAssiette.push(assiette);// Ajouter l'assiette sur la pile:

}

Les Assiette ne se lavent pas dans n'importe quel ordre. Non monsieur! Le plongeur musclé et ténébreux prend
toujours l'Assiette sur le dessus de la pile pour la nettoyer. Et prend la prochaine ensuite. Si d'autres Assiette
s'ajoutent entretemps, c'est encore celle sur le dessus qu'il prendra pour la nettoyer (est-ce que je vous ai dit qu'il était
musclé et ténébreux?).

C'est le principe d'une Pile (LIFO): on peut seulement ajouter des nouveaux éléments sur le dessus de la pile, et on peut
seulement retirer le dernier élément qui a été ajouté. Précisons qu'on peut enlever autant d'élément qu'on veut, mais
seulement un à la fois et toujours en partant du dessus de la pile.

Assiette que le plongeur va laver en premier

Avec une pile, on peut faire plusieurs opérations pratiques:

• Déposer une assiette au sommet de la pile ;

• Prendre l'assiette au sommet ;
• Savoir combien d’assiettes il y a.

On ne peut pas accéder à n’importe quelle assiette… uniquement à celle qui se

trouve au sommet de la pile!

Maintenant qu'on comprend tous bien ce qu'est une pile (oui, même le gars dans le fond qui ronfle un peu), comment
on utilise ça concrètement une pile en Java?

8
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Stack (Les piles en Java)

.push(assiette) .pop()

.garocher()

Stack<TypeObjet> pile = new Stack<>();

Opération avec Stack Description

pile.push(element) Ajoute element au sommet de la pile
pile.pop() Renvoie et retire l’élément au sommet de la pile
pile.peek() Renvoie l’élément au sommet (sans le retirer de la pile)
pile.isEmpty() Renvoie un booléen (true si la pile est vide, false sinon)
pile.size() Renvoie le nombre d’éléments qui se trouvent actuellement dans la pile

.ovni()

9
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Exemple d'utilisation d'une pile (Stack)

public static void main(String[] args) {
Stack<String> pile = new Stack<>();

System.out.println(pile.isEmpty());

pile.push("Bleu");
pile.push("Blanc");
pile.push("Violet");

String couleur = pile.peek();

System.out.println(couleur); // Résultat ?

couleur = pile.pop();
System.out.println(couleur); // Résultat ?

pile.push("Vert");
System.out.println(pile.size()); // Résultat ?

System.out.println(pile.pop()); // Résultat ?
System.out.println(pile.pop()); // Résultat ?
System.out.println(pile.pop()); // Résultat ?
}

Réponses :
true
Violet
Violet
3
Vert
Blanc
Bleu

10
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Files (FIFO → First In, First Out)

C'est une "liste" qui suit une logique particulière dans son utilisation. Nous allons débuter l'explication par un exemple
simple :

Histoire vécue d'un gars et de sa date dans une pizzeria de quartier un certain soir d'automne de pleine lune
C'était un soir de pleine lune, un certain samedi soir d'automne. Une belle soirée chaude, une des dernières de l'année
probablement avant le froid inévitable de l'hiver qui allait frapper à nos portes. Tout le monde en profitait, dans les
restos, dans les bars, dans les salles de bingo, vraiment tout le monde savourait les derniers instants qui ne sauraient
durer.

Tout le monde?

Et bien non. Un jeune homme, musclé et ténébreux, avait tout organisé pour que sa date se passe super bien. Tout
d'abord il irait avec une jolie demoiselle au petit resto du coin. Ensuite il irait se promener sur le bord de la
Rivière-des-Mille-Îles main dans la main avec celle qu'il désirait depuis plusieurs mois déjà, pour ensuite finir ça à la
maison autour d'une partie de Super Smash Bros. Le plan parfait.

Malheureusement, tout le monde s'était donné le mot pour arriver au restaurant en même temps. En fait, 5 minutes
avant lui. L'attente était interminable, il maugréait devant la file de personnes qui attendaient devant eux, en hurlant de
désespoir.

Et la morale de cette histoire?

Laisse faire le resto le grand, et la prochaine fois montre tout de suite à ta date comment t'es bon à Super Smash Bros.
Ça, ça va l'impressionner.1

1
Le prof ne saurait être tenu responsable des conséquences liées aux suggestions de sorties de couples.

11
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Files (FIFO → First In, First Out)

Imaginez que vous voulez modéliser le problème de la file de monde devant la porte d'une petite pizzeria de quartier
(mais pourquoi pas ?). On aurait une classe Personne, avec plein d'instances de cette classe Personne pour
représenter chacune des Personne dans la file:

LinkedBlockingQueue<Personne> filePersonne = new LinkedBlockingQueue<>(); // Une file

for (int i = 0; i < 25; i++){

Personne personne = new Personne();

// Ajouter la personne à la file:

filePersonne.offer(personne);
}

Les Personne ne sont pas servies dans n'importe quel ordre. Non madame! Le restaurant accepte toujours la personne
qui attend en file depuis le plus longtemps, soit celle qui est le plus près de la porte. Et prend la prochaine ensuite. Et
ainsi de suite. Si d'autres Personne s'ajoutent entretemps à la fin de la file, c'est encore celle le plus près de la porte qui
sera admise (la Personne qui était arrivée en premier parmi toutes les Personne de la file).

C'est le principe d'une File (FIFO): on peut seulement ajouter des nouveaux éléments à la fin de la file, et on peut
seulement retirer le premier élément de la file. Précisons qu'on peut enlever autant d'élément qu'on veut, mais
seulement un à la fois et toujours en partant du début de la file.
Les derniers arrivés se
mettent à la fin de la file et
attendent leur tour.

Un petit rusé qui pense pouvoir

couper pour rentrer plus vite
dans le resto. Mais ce n'est pas
permis! Oh que non!
Prochain à entrer dans le resto, en tête de file. Il attend depuis longtemps!

12
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Avec une file FIFO, on peut faire plusieurs opérations pratiques:

• Faire entrer un élément à la fin ;

• Faire sortir un élément à la tête ;
• Savoir combien d'éléments il y en a dans la file.

Mais on ne peut pas accéder à un élément autre que celui en tête de la file!

Maintenant qu'on comprend tous bien ce qu'est une file (oui, même la fille dans le fond qui ronfle un peu), comment on
utilise ça concrètement une file en Java?

LinkedBlockingQueue (Les files en Java)

LinkedBlockingQueue <TypeObjet> file = new LinkedBlockingQueue<>();

Opération avec Queue Description

file.offer(element) Ajoute element à la fin de la file
file.poll() Renvoie et retire l’élément en tête de file
file.peek() Renvoie l’élément à la tête de la file (sans le retirer de la file)
file.isEmpty() Renvoie un booléen (true si la file est vide, false sinon)
file.size() Renvoie le nombre d’éléments qui se trouvent actuellement dans la file

13
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Exemple d'utilisation d'une file (LinkedBlockingQueue)

public static void main(String[] args) {
LinkedBlockingQueue<String> file = new LinkedBlockingQueue<>();

System.out.println(file.isEmpty());

file.offer("Bleu");
file.offer("Blanc");
file.offer("Violet");

String couleur = file.peek();

System.out.println(couleur); // Résultat ?

couleur = file.poll();
System.out.println(couleur); // Résultat ?

file.offer("Vert");
System.out.println(file.size()); // Résultat ?

System.out.println(file.poll()); // Résultat ?
System.out.println(file.poll()); // Résultat ?
System.out.println(file.poll()); // Résultat ?
}

Réponses :
true
bleu
bleu
blanc
3
violet
vert

Comment choisir la structure à utiliser ?

Selon le comportement que je veux:

 Piles et files : généralement quand on veut simuler une situation spécifique où des objets se comportent comme
des piles ou des files du monde réel…

➢ Ex. une pile de livres, une liste d’attente dans un système de soutien technique, etc.

 Listes : cas général

➢ Permettent de remplacer les tableaux

➢ Plus de fonctionnalités…
➢ Flexibles…

14
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Valeur de retour de .garocher()

15
Mathieu Grenon et des professeurs d’informatique 420-202-RE

.toString()

Toutes les classes en Java héritent de la classe Object, c'est-à-dire qu’ils partagent des attributs et des méthodes qui
sont définie dans cette classe parent :

Object

String Scanner BufferedReader Pion Girafe Banane

. …

La classe Object contient plusieurs méthodes qu’on peut utiliser dans toutes les autres classes, telles que :

- .toString()
- .equals()
- Etc.

Qui peuvent être appelées sur toutes les classes de Java.

La méthode toString() retourne une chaîne de caractère qui indique ce que représente l’objet.

C’est très pratique pour faire tout simplement :

System.out.println(monObjet);

Au lieu de :

System.out.println (monObjet.getAttribute1() + " " + monObjet.getAttribute1() …); //Non !

16
Mathieu Grenon et des professeurs d’informatique 420-202-RE

Comme on a dit, la méthode toString() existe pour tous les objets et toutes les classes… mais quand on définit nos
propres classes la méthode toString() ne sait pas quoi afficher exactement : il faut lui dire nous-même :

Exemple pour une classe Cercle qu’on aurait écrit:

public class Cercle {

private double rayon;

public Cercle (double rayon) {

this.rayon = rayon;
}

@Override
public String toString() {
return "Cercle de rayon = " + rayon;
}
}

Attention :

Remarquez que toString() ne fait pas l’affichage (println) elle-même! Elle retourne tout simplement une
« version String » de l’objet. À vous de décider ce que vous ferez, tel que :

Cercle monCercle = new Cercle(5);

// Va appeler .toString() du cercle automatiquement!

System.out.println(monCercle);

17