Cours 5 - Les collections

name: inverse
layout: true
class: center, middle, inverse

---
# JAVA - Cours 5
## Les collections
## Inès de Courchelle

![image](img/CY-tech.png)

---
layout: false

# Rappel
## Les héritages

#### Modélisation
<center>
    <img src="img/ex1.png"  width=400/>
</center>

#### Attention
- Une classe ne peut hériter que d’une seule classe à la fois
- Une classe dérive de java.lang.object
- Une classe final ne peut pas être redéfinie !
- L'opérateur instanceOf permet de détermininer la classe d’une instance

---
# Rappels
## Interfaces VS Abstraites

- Une interface n'a aucune implémentation d'opérations
- Une classe dite abstraite possède au moins une méthode non implémentée.

<br>

---
# Rappels
## static - final
- Final qui ne peut être redéfinie !
- Static qui utilise des variables static !

.underR[Mais Encore ?]
```java
public class MaClasseDeConstantes {
  private static final int TAILLE = 42;
}
```
<center>
    <img src="https://media.giphy.com/media/NJeO7eXfxVIK4/giphy.gif"  width=400/>
</center>

---
# Today
## Objectifs

- Utiliser des collections
- Lire la documentation
- Faire la différence entre les types et les types primitifs

---
# Les collections
## Définitions
.otro-blockquote[Une collection représente un groupe d’objets, connu par ses éléments. Certaines collections acceptent les doublons, d’autres pas. Certaines sont ordonnées, d’autres pas. Quelques exemples : arrayList hashmap.]

.otro-blockquote[C’est une infrastructure avec un ensemble de ressources qui forment un système technique cohérent.]

---
# Les différents types de collections
## 3 grandes familles de collections
- List
- Map
- Set

## Plusieurs façon de parcourir les collections
- Iterator
- Enumeration
- Boucles (for, while, foreach ...)

---
# Les LISTs
## Objectifs
- Stocker des données d'un tableau
- Obtenir des fonctions déjà codées pour gérer la liste !

---
# ArrayList
## Description
<img src="img/arraylist1.png"  width=600/>

---
# ArrayList
## Mais que peut-on faire avec un ArrayList ?
.pull-left[
-   Ajouter un élément
-   Parcourir l’ArrayList
    -   Enumération
    -   Foreach
    -   Iterator
-   Vider la liste
-   Supprimer un élèment
-   ...
-   La liste complète est sur [la Doc](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/ArrayList.html)
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/cXblnKXr2BQOaYnTni/giphy.gif"  width=290/>
</center>
]

---
# ArrayList
## Création d'un ArrayList
```java
ArrayList <String> lesChats= new ArrayList<String>();
```

## Ajouter des éléments dans un ArrayList
```java
lesChats.add("British shorthair");
lesChats.add("Maine coon");
lesChats.add("Ragdoll");
lesChats.add("Bombay");
```

---
# ArrayList
## Parcourir un ArrayList
```java
/*solution 1*/
for (int i=0; i<lesChats.size();i++)
  System.out.println(lesChats.get(i));
/*solution 2 */
for (String temp: lesChats)
  System.out.println(temp);
/*solution 3*/
lesChats.forEach((c)-> System.out.println(c));
```
## OUTPUT : le même pour les 3 solutions
```shell
  British shorthair
  Maine coon
  Ragdoll
  Bombay
```
---
# ArrayList
## Exemple à Poudlard
#### Création d'une classe Eleve
.pull-left[
<img src="img/eleveClasse.png" width=200>
]

.pull-right[
```java
public class Eleve {
    /* les attributs */
    private String nom;
    private String prenom;
    private int points;

/* les constructeurs */
    public Eleve (String nom, String prenom, int points){
        this.nom=nom;
        this.prenom=prenom;
        this.points=points;
    }
    /*getter + setter */
    ...
}
```
]
---
# ArrayList
## Exemple à Poudlard
#### Création d'une liste d'élèves
```java
ArrayList <Eleve> gryffondor= new ArrayList<Eleve>();
```
<img src="img/arrayListGryffond.png" width=300>

---
# ArrayList
## Exemple à Poudlard
#### Instanciation
```java
Eleve e1 = new Eleve("Potter","Harry",-150);
Eleve e2 = new Eleve("Weasley","Ron",-150);
Eleve e3 = new Eleve("Granger","Hermione",200);
```
<img src="img/instancierObjetEleve.png" width=370>

---
# ArrayList
## Exemple à Poudlard
#### Ajout des élèves dans la liste
<img src="img/arrayListEleveGryf.png" width=500>

---
# ArrayList
## Exemple à Poudlard

```java
/* Création d'une liste d'élèves */
ArrayList <Eleve> gryffondor= new ArrayList<Eleve>();
/* Création d'élèves */
Eleve e1 = new Eleve("Potter","Harry",-150);
Eleve e2 = new Eleve("Weasley","Ron",-150);
Eleve e3 = new Eleve("Granger","Hermione",200);

/* Ajout des élèves dans gryffondor */
gryffondor.add(e1);
gryffondor.add(e2);
gryffondor.add(e3);

```
---
# ArrayList
## Exemple à poudlard
#### Affichage
```java
/* Parcourir la liste */
for (int i=0; i<gryffondor.size();i++) {
  /* ici cela nous renvoi l'objet */
  System.out.println("Eleve à gryffondor = " + gryffondor.get(i));
  /* ici cela nous renvoi l'objet puis on va chercher nom */
  System.out.println("Eleve à gryffondor = " + gryffondor.get(i).getNom());
}
```
#### OUTPUT
```bash
  Object Eleve à gryffondor = Eleve@6d06d69c
  Eleve à gryffondor = Potter
  Object Eleve à gryffondor = Eleve@7852e922
  Eleve à gryffondor = Weasley
  Object Eleve à gryffondor = Eleve@4e25154f
  Eleve à gryffondor = Granger
```
---
# ArrayList
## Réflexion

Comment peut-on directement afficher un élève (nom, prenom ...) sans changer le premier System.out.println()?
.pull-left[
<center>
    <img src="https://media.giphy.com/media/PPw87BtlPrQIg/giphy.gif"  width=290/>
</center>

]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/N3tNKBmQR3K2k/giphy.gif"  width=360/>
</center>

]

---
# Iterator 1/3
## Définition
- Un itérateur est un objet qui a pour rôle de parcourir une collection
- Quelque soit la collection, on peut parcourir tous ses éléments
- 3 lignes :
```java
Iterator<String> i= maCollection.iterator();
while (i.hasNext())
    System.out.println(i.next());
```

---
# Iterator 2/3
## Exemple 1
```java
/* Liste de String */
ArrayList<String> listeDeCaracteres = new ArrayList<String>();
listeDeCaracteres.add("Led Zeppelin");
listeDeCaracteres.add("Sonic Youth");

Iterator<String> i1= listeDeCaracteres.iterator();
while (i1.hasNext())
  System.out.println(i1.next());
```

#### OUTPUT
.pull-left[
```shell
  Led Zeppelin
  Sonic Youth
```
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/1SxGdclHU5sxTWNqo9/giphy.gif"  width=200/>
</center>
]
---
# Iterator 3/3
## Exemple 2
```java
Personne p1 = new Personne(01,"Jimmy","Page");
Personne p2 = new Personne(02,"Patti","Smith");
Personne p3 = new Personne(03,"Ricky","Nelson");
ArrayList<Personne> listePersonne = new ArrayList<Personne>();
listePersonne.add(p1);
listePersonne.add(p2);
listePersonne.add(p3);

Iterator<Personne> i = listePersonne.iterator();
while (i.hasNext())
  System.out.println(i.next().getprenom());
```
#### OUTPUT
.pull-left[
```shell
 Jimmy
 Patti
 Ricky
```
]
.pull-right[
<center>
    <img src="img/ricky.png"  width=200/>
</center>

]
---
# Vector 1/2
## Exemple 1
```java
/*Creation d'un vector */
Vector<Integer> v1 = new Vector<Integer>();
/*Ajout de valeur à l'interieur */
v1.add(1);
v1.add(2);
v1.add(3);
v1.add(4);
/*affichage */
System.out.println(v1);
```
#### Output
.pull-left[
```shell
[1, 2, 3, 4]
```
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/qsVHzq6FL4aaY/giphy.gif"  width=200/>
</center>
]
---
# Vector 2/2
## Exemple 2
```java
/*Creation d'un vector */
Vector<String> v2 = new Vector<String>();
/*Ajout de valeur à l'interieur */
v2.add("Batman Begins");
v2.add("The Dark Knight");
v2.add("The Dark Knight Rises");
/*affichage */
System.out.println(v2);
```

#### Output
```shell
[Batman Begins, The Dark Knight, The Dark Knight Rises]
```
<center>
    <img src="https://media.giphy.com/media/C7RCCFdaixA3u/giphy.gif"  width=200/>
</center>

---
# LinkedList 1/2
## Exemple 1

```java
/* Création d'un objet Linkedlist */
List<String> mesPrenoms = new LinkedList<String>();
/* Ajouter d'élement dans un linkedlist */
mesPrenoms.add("James");
mesPrenoms.add("Robert");
mesPrenoms.add("John");
/* Parcourir
for(int i = 0; i < mesPrenoms.size(); i++)
    System.out.println("Élément à l'index " + i + " = " + mesPrenoms.get(i));
```
#### Output
.pull-left[
```bash
Élément à index 0 = James
Élément à index 1 = Robert
Élément à index 2 = John
```
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/7wuKP3Fx911o4/giphy.gif"  width=170/>
</center>

]
---
# LinkedList 2/2
## Exemple 2
```java
/* Création d'un objet Linkedlist */
List<String> mesPrenoms = new LinkedList<String>();
/* Ajouter d'élement dans un linkedlist */
mesPrenoms.add("James");
mesPrenoms.add("Robert");
mesPrenoms.add("John");
mesPrenoms.add("Bonzo");
System.out.println("LinkedList: "+mesPrenoms);

```
#### Output
```bash
LinkedList: [James,Robert,John,Bonzo]
```
<center>
    <img src="https://media.giphy.com/media/RsAHGKZXFHPtm/giphy.gif"  width=140/>
</center>

---
# Mise en garde - Import 1/2
Pour pouvoir utiliser les collections assurées d'avoir fait les bons Imports !
<center>
    <img src="img/importEclipse.png"  width=500/>
</center>

.underV[Eclipse est là pour nous aider !]

---
# Mise en garde - Import 1/2
<center>
    <img src="img/attentionImport.png"  width=500/>
</center>

.underR[Attention] Pour l'utilisation des LISTs il faut utiliser le bon import !
```java
import java.util.List;
/* ensuite si on veut des linkedList ! */
import java.util.LinkedList;
/* ensuite si on veut des ArrayList ! */
import java.util.ArrayList;
```

.under[Idem pour les autres collections qu'on va voir après ! ]

- C'est un peu comme le include en C !
- Dès qu'on utilise une fonctionnalité, on importe la bibliothèque qui nous va avec !

---
# Micro bilan des LISTs !
- Il existe des différences entre ces 3 structures
- Pour savoir quelles fonctionnalités on peut utiliser :  [laDoc](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html)

1. [ArrayList](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/ArrayList.html)
2. [Vector](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Vector.html)
3. [LinkedList](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/LinkedList.html)

---
# Les MAPs
## Objectif
Avoir un couple de données (clé+donnée)

## Les différentes types de maps
- HashMap
- HashTable
- TreeMap
- WeakHashMap

---
# HashMap 1/3
## Petites précisions
-   Classe API Java
-   Constructeur (clé unique,valeur)
-   Pas de doublons de clé
-   Collection de couples de deux objets de type différents ou identiques
-   Comportement différent pour l’iterateur

## Description
<center>
    <img src="img/hashmap.png"  width=600/>
</center>

---
# HashMap 2/3
## Exemple
```java
/* Meilleur groupe de rock par année */
HashMap<Integer,String> rockList = new HashMap<Integer,String>();
rockList.put(1970, "Led Zepplin");
rockList.put(1971, "Led Zepplin");
rockList.put(1975, "Queen");
rockList.put(1985, "Motley Crue");
```
<center>
    <img src="https://media.giphy.com/media/DIabNXDGI6etO/giphy.gif"  width=300/>
</center>

---
# HashMap 3/3
## Le parcours
```java
/* Obtenir un couple rockList */
Set<Entry<Integer, String>> entrySet = rockList.entrySet();
/* Obtenir un iterator pour notre couple précédement créé */
Iterator<Entry<Integer, String>> it = entrySet.iterator();
while(it.hasNext()){
  Map.Entry<Integer,String> me = (Map.Entry<Integer,String>)it.next();
  System.out.println("La clé est : "+me.getKey() + " & " + " la valeur est : "+me.getValue());
}
```
#### OUTPUT
```bash
  La clé est : 1985 &  la valeur est : Motley Crue
  La clé est : 1970 &  la valeur est : Led Zepplin
  La clé est : 1971 &  la valeur est : Led Zepplin
  La clé est : 1975 &  la valeur est : Queen
```

---
# HashTable 1/2
## Exemple
```java
/* Création de la HashTable */
Hashtable<String,String> maTable= new Hashtable<String,String>();

/* on ajoute une clé et une valeur */
lordOfTheRing.put("film1","La communauté de l'anneau");
lordOfTheRing.put("film2","Les deux tours");
lordOfTheRing.put("film3","Le retour du roi");
```
<center>
    <img src="https://media.giphy.com/media/zGnnFpOB1OjMQ/giphy.gif"  width=300/>
</center>

---
# HashTable 2/2
## Exemple
```java
/* Nous pouvons réaliser un iterateur (comme un HashMap)*/
/* Mais nous pouvons aussi utiliser cette solution de parcours */
/* Une énumeration */
Enumeration<String> names = lordOfTheRing.keys();
while(names.hasMoreElements()) {
  String key = names.nextElement();
  System.out.println("La clé : " +key+ " & La valeur: " + lordOfTheRing.get(key));
}
```
#### OUTPUT
```bash
La clé : film1 & La valeur: La communauté de l'anneau
La clé : film3 & La valeur: Le retour du roi
La clé : film2 & La valeur: Les deux tours
```
---
# TreeMap
## Exemple
```java
/* Déclaration du treeMap */
TreeMap<Integer, String> mesTree=  new TreeMap<Integer, String>();
/*Ajout d'élément dans le TreeMap*/
mesTree.put(1, "Chêne");
mesTree.put(23, "Cocotier");
mesTree.put(70, "Platane");
mesTree.put(4, "Érable");
/* Affichage avec un foreach*/
mesTree.forEach((cle,valeur) -> System.out.println("ma cle "+cle+" - "+valeur));
```
#### OUTPUT
.pull-left[
```bash
ma cle 1 - Chêne
ma cle 4 - Érable
a cle 23 - Cocotier
ma cle 70 - Platane
```
]
.pull-right[
<center>
    <img src="img/minecraft2.jpeg"  width=250/>
</center>
]

---
# WeakHashMap 1/2
## Exemple
```java
/*Creation du Weakhashmap */
WeakHashMap<Integer, String> topRock = new WeakHashMap<Integer, String>();

/* ajout */
topRock.put(1, "Led Zeppelin");
topRock.put(2, "Queen");
topRock.put(3, "Aerosmith");

/*affichage*/
for(int i=0;i<topRock.size();i++)
  System.out.println("classement : "+topRock.get(i));
```
#### Output
.pull-left[
```java
classement : null
classement : Led Zeppelin
classement : Queen
```
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/kG2fPOzwrILlgGbK2d/giphy.gif"  width=130/>
</center>

]
---
# WeakHashMap 2/2
## Exemple
```java
/*Creation du Weakhashmap */
WeakHashMap<Integer, String> topRock = new WeakHashMap<Integer, String>();

/* ajout */
topRock.put(1, "Led Zeppelin");
topRock.put(2, "Queen");
topRock.put(3, "Aerosmith");

/*affichage*/
for(int i=1;i<topRock.size()+1;i++)
  System.out.println("classement : "+topRock.get(i));
```
#### Output
.pull-left[
```java
classement : Led Zeppelin
classement : Queen
classement : Aerosmith
```
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/1AhOXp2qpdBtdyKJB9/giphy.gif"  width=200/>
</center>

]

---
# Micro bilan des MAPs !
- Utile lorsque l’on a besoin d’une clé unique
- Objet le plus utilisé reste HashMap
- Pour savoir quelles fonctionnalités on peut utiliser :  [laDoc](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Map.html)

1. [HashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashMap.html)
2. [HashTable](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Hashtable.html)
3. [TreeMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/TreeMap.html)
4. [WeakHashMap](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/WeakHashMap.html)

---
# Les SETs
## Objectifs
Avoir un couple de données (clé+donnée) MAIS sans Doublons !
- HashSet
- TreeSet
- LinkedHashSet

---
# HashSet 1/2
## Description
<center>
    <img src="img/HashSet.png"  width=600/>
</center>

---
# HashSet 2/2
## Exemple
```java
/* création du HashSet */
HashSet<String> persoListe= new HashSet<String>();
/* ajout des personnages */
persoListe.add("Mario");
persoListe.add("Luigi");
persoListe.add("Zelda");
/*creation d'un iterateur */
Iterator<String> it= persoListe.iterator();
/*affichage */
while(it.hasNext())
  System.out.println(it.next());
```

#### OUTPUT
.pull-left[
```bash
Luigi
Zelda
Mario
```
]
.pull-right[
<center>
    <img src="https://media.giphy.com/media/mBFuGuduqZUAgAJqBf/giphy.gif"  width=200/>
</center>

]
---
# TreeSet
## Exemple
```java
/* Déclaration du treeMap */
TreeMap<Integer, String> mesTree=  new TreeMap<Integer, String>();
/*Ajout d'élément dans le TreeMap*/
mesTree.put(1, "Chêne");
mesTree.put(23, "Cocotier");
mesTree.put(70, "Platane");
mesTree.put(4, "Érable");
/* Affichage avec un foreach*/
mesTree.forEach((cle,valeur) -> System.out.println("ma cle "+cle+" - "+valeur));
```
#### OUTPUT
.pull-left[
```bash
  ma cle 1 - Chêne
  ma cle 4 - Érable
  ma cle 23 - Cocotier
  ma cle 70 - Platane
```
]
.pull-right[
<center>
    <img src="img/mojozelda.jpeg"  width=220/>
</center>

]

---
# LinkedHashSet
## Exemple
```java
/* Déclaration du LinkedHashSet */
LinkedHashSet<String> jours = new LinkedHashSet<String>();

/*Ajout d'élément dans le LinkedHashSet*/
jours.add("Lundi"); jours.add("mardi");
jours.add("mercredi"); jours.add("jeudi");
jours.add("vendredi"); jours.add("samedi");
jours.add("dimanche");

/* Affichage */
System.out.println(jours);
```
#### OUTPUT
```bash
[Lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche]
```

---
# Micro bilan des SETs !
- Utile lorsque l’on a besoin d’une clé unique et de aucuns doublons
- Objet le plus utilisé reste HashSet
- Pour savoir quelles fonctionnalités on peut utiliser :  [laDoc](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Set.html)

1. [HashSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/HashSet.html)
2. [TreeSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/TreeSet.html)
3. [LinkedHashSet](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/LinkedHashSet.html)

---
# L'interface collection 1/2

.underV[Java c'est un diagramme de classes UML Géant !]
<center>
    <img src="img/collectionsUML.png"  width=600/>
</center>

[source - diagramme ](https://www.codejava.net/java-core/collections/overview-of-java-collections-framework-api-uml-diagram)

---
# L'interface collection 2/2

- Toutes ces classes sont déjà codées !
- Pour les manipuler, il faut :
  - créer des objets, attention au type
  - créer des classes qui << implements >> une interface de la biblio java
  - ...

.underV[NE pas avoir peur de la DOC ! ]

---
# Les types  1/3
## Les types issues de Classe - C'est la même !
- Il existe déjà des classes pré-codées pour String, Integer, Double ...
- Elles commencent toujours pas une majuscule

##  Les types primitifs
- Les types primitifs ne sont pas des classes
- C'est un type comme en C, avec int, char ...
- [Rappel : On l'a apperçu dans des diapos avant](../../CM/CM2/cm2.html#9)
- Aucunes fonctionnalités n'existent à leur sujet !

---
# Les types 2/3
## Exemple 1 - String
```java
String maChaine = new String("LedZeppelin");
System.out.println(maChaine.substring(3));
```

## Output
```bash
Zeppelin
```
- Ici, la méthode substring décrite [ICI](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html) renvoi la chaîne de caractères à partir de l'index 3
- Je peux réaliser cette fonctionnalités car

<br>
<center>
.underV[maChaine est un Objet de type String !]
</center>

---
# Les types 3/4
## Exemple 2 - Integer
```java
Integer a = new Integer(4);
System.out.println(a.floatValue());
```
#### Output
```bash
4.0
```
#### Exemple 3 - ERROR
```java
int b =4;
System.out.println(b.floatValue());
```
#### Output
```bash
 java.lang.Error: Unresolved compilation problem:
 Cannot invoke floatValue() on the primitive type int
```

---
# Les types 4/4
## Exemple 4
```java
Public class Personne {
    private String nom;
    private Double age;
    ...
}
```
<center>
    <img src="https://media.giphy.com/media/x6hRCDKc64icg/giphy.gif"  width=400/>
</center>

---
# Bilan

- La doc est super importante !
- ECLIPSE est mon ami
  - Les collections sont nombreuses !
  - Si je veux un tableau, alors j'utilise plutôt des LISTs
  - Si je veux un couple de données, alors j'utilise plutôt des SETs ou des MAPs
- Attention aux types que l'on manipule
  - Si ces des primitifs, alors aucune fonctionnalité n'est dispo !
  - Si ces des objets, alors des fonctionnalités existent

---
# Bonus
## Exemple de collection
<iframe width="560" height="315" src="https://www.youtube.com/embed/RoFeLaROdtk" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>