Les collections en Java

## Les collections en Java
### Université du Havre - LITIS
#### L2 Math-Info - Spécialisation informatique
[D. Olivier](http://litis.univ-lehavre.fr/~olivier/PagePerso)

## Plan du cours
* [Généralités](#/2)
* [Généricité](#/3)
* [Collections](#/8)
* [Parcourir une collection](#/10)
* [Exemple](#/13)

# Généralités

## Généralités
* Une collection est un objet qui contient d'autres objets.
* Les collections font appels à la généricité de type.

# Généricité

## Généricité
<div style="font-size:100%;text-align:justify;">
<ul>
  <li>Avant Java 1.5, les collections peuvent contenir n'importe quel type d'objets.</li>
  <li>Après, on peut indiquer le type des objets contenus dans une collection grâce à la généricité.

```java
    List<Employe> liste = new ArrayList<Employe>();
```

On a créé une liste de `Employe` ;</li>
  <li>La syntaxe pour mettre en œuvre la généricité utilise les symboles <code><</code> et <code>></code> pour préciser le ou
  les types des objets à utiliser.</li>
  <li>Seuls des objets peuvent être utilisés avec la généricité : si un type primitif est utilisé dans les generics,
  une erreur de type `unexpected type` est générée lors de la compilation.</li>
</ul>  
</div>

## Généricité et polymorphisme

* Pas de polymorphisme sur le type.
	* Il n'est pas possible d'utiliser `List<String>` pour référencer une variable `List<Object>`
	* Si c'était permis on pourrait ajouter des objets de type incompatible grace au type le plus générique.
* Idem pour le passage de paramètre.
	* Soit `afficheCollection(List<Personne> l)`, même si `Employee` est une classe dérivée de `Personne`, vous ne pouvez pas appeler votre méthode avec une variable de ce type.

</div>

## Généricité et polymorphisme
```java
import java.util.*;

public class GeneriqueTypeErreur {
    public static void main( String[] args) {
        List<Mouton> bergerie = new ArrayList<Mouton>();
        bergerie.add(new Mouton());

// Erreur compilation
        List<Object> objs = bergerie;
        // Sinon on pourrait écrire !!!
        objs.add( new Loup() );
        // Et il y aurait un loup dans la bergerie .....
        }
    }
```

## Méthodes génériques
* Prévues pour fonctionner avec une variété de type ;
* Les types des paramètres sont entre `< >`.
```java
static <T> void addToCollection(T p, Collection<T> c) {
    c.add(p);
}
```

## Type jocker
* Le paramètre de type jocker ```?``` est interprété comme type inconnu.
* Ainsi déclarer une variable comme ```List<?>``` signifie que vous pouvez stocker n'importe quel type d'objet.
* On ne peut faire aucune hypothèse sur le type des objets stockés.

## Type jocker
```java
import java.util.*;

public class GeneriqueJockerExemple {
    public static void main( String[] args) {
        List<Mouton> bergerie = new ArrayList<Mouton>();
        bergerie.add(new Mouton()));

List<?> objs = bergerie;

for (Object o: objs) { // On remarquera la boucle (cf. suite)
            System.out.println(o + " est dans la bergerie.");
        }
    }
```

## Contraindre un type générique
* Lors de l'utilisation d'un type générique ```T1``` ou ```?``` il est possible de le contraindre 
*  ```? extends T``` ou ```T1 extends T```
	* ```?``` ou ```T1``` représentent une classe ***ou une interface*** "fille".
*  ```? super T``` ou ```T1 super T```
	* ```?``` ou ```T1``` doivent être une classe ou une interface ancêtre. (Autre sens dans l'arbre d'héritage).
* Syntaxe ```<T extends type>``` et ```<T super type>```

## Exemple de contrainte (1)
```java
public class Animal {
	String nourriture;

public Animal(String bouffe) {
		nourriture = bouffe;
    }

public Animal() {
		this("Vent"),
	}

public String mangeQuoi() {
        return nourriture,
    }
}

public abstract class Proprietaire <T extends Animal>{
	protected T animalCompagnie;

public Proprietaire(T a) {
		animalCompagnie = a;
	}
	public abstract void recompenseAnimalCompagnie();
}

public class Chien extends Animal {
	public Chien() {
		super("Croquettes");
		System.out.println(("Wouf"));
	}

public void caresse()
	{
		System.out.println("Hou que c'est bon, encore");
	}
}

public class Berger extends Proprietaire<Chien>{ // Chien hérite bien de Animal
	public Berger(Chien toutou) {
		super(toutou);
	}

public void recompenseAnimalCompagnie() {
		animalCompagnie.caresse();
	}
}
```

## Exemple de contrainte (2)
* Interface : `java.util.List` nous permet de gérer des listes d'objets auxquels nous pouvons accéder via un index.
* Classe : `java.util.ArrayList` tableau dynamique, implante l'interface `List`.

```java
import java.util.ArrayList;
import java.util.List;

public class GeneriqueJocker3 {

public GeneriqueJocker3() {
	}

public static void main( String[] args) {
		List<Mouton> bergerie = new ArrayList<Mouton>();
		bergerie.add(new Mouton());

List<? extends Animal> objs = bergerie;

// On peut utiliser la méthode mangeQuoi()
		for (Animal o: objs) {
			System.out.println("Je mange : "+ o.mangeQuoi());
		}
		// On ne peut toujours pas mettre un loup dans la bergerie
		// bergerie.add(new Loup());
	}
}
```

### Utilisation de ? et contraintes
* L'utilisation de ```<? ...>``` dépendra du rôle que joue le
paramètre générique dans la méthode :
  * En entrée de méthode : définis avec ```extends```  
    * Sauf si accédé exclusivement avec des méthodes de Object, on utilise un joker non borné ;
  * En sortie : définis avec ```super```   
  * En entrée/sortie et en retour : pas de jocker !

### Considérations générales
* Lors de l'introduction de la généricité dans le langage, la machine
virtuelle n'a pas été modifiée. Une classe paramétrée est compilée
en une classe non paramétrée.
* Les variables de types sont donc oubliées après la
compilation (type erasure). Certaines opérations qui utilisent les
types génériques à l'exécution ( par exemple certains transtypages,
création d'objets, ```instanceof``` , ... ) ne sont donc pas
autorisées et provoquent donc des erreurs  lors de la compilation.

```java
public class UneClasse<T> {
  ...
  T temp = new T(); // Erreur à la compilation
  ...
}
```

# Collections

## Collections - généralités
* Une collection est un objet qui contient d'autres objets.
* Par exemple, un tableau est une collection.
* Java fournit d'autres types de collections sous la forme de classes et d'interfaces.
* Ces classes et interfaces sont dans le paquetage [```java.util```](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/package-summary.html).

## Collection et généricité
* Avant Java 1.5, les collections peuvent contenir n'importe quel type d'objets ;
* Après, on peut indiquer le type des objets contenus dans une collection grâce à la généricité.
 `List<String> liste = new ArrayList<String>();`
   + On a créé une liste de `String` ;

* Exemple de programme qui pouvait poser problème :

```java
Collection pommes = new ArrayList() ;
pommes.add(new Pomme()) ;
pommes.add(new Pomme()) ;
pommes.add(new Scoubidou()) ;
for(int i=0; i<pommes.size(); i++){
    // erreur exécution à la 3me itération
    Pomme p = (Pomme)pommes.get(i) ;
    p.extraireJus() ;
}
```

## Collection et généricité

```java
Collection<Pomme> pommes = new ArrayList<Pomme>() ;
pommes.add(new Pomme()) ;
pommes.add(new Pomme()) ;
/* pommes.add(new Scoubidou()) ; */
// erreur de compilation
for(int i=0 ;i<pommes.size() ;i++){
    Pomme p = pommes.get(i) ; // casting implicite
    p.extraireJus() ;
}
```

## Les interfaces
* Deux hiérarchies d'héritage principales :
    * ```Collection<E>```<br>implementée par la plupart des classes qui gèrent des collections ;
    *  ```Map<K,V>```<br>collections indexées par des clés ;  définit des méthodes pour des objets qui gèrent des collections sous la forme clé/valeur ;

## Hiérarchie des interfaces

![Collections](images/collections.gif)

* Il existe des classes abstraites qui implémentent un squelette ```AbstractXXX``` (ex : ```AbstractList```).

## Hierachie des interfaces
* Il existe des classes concrètes qui implémentent ces interfaces.

| | ```Set<E>``` | ```List<E>``` | ```Map<K,V>``` | ```Deque<E>``` |
| --- | --- | ---- | --- | --- |
| Tableau redimensionnable |	   | ```ArrayList<E>``` | | ```ArrayDeque<E>``` 	|
| Arbre	|	```TreeSet<E>``` |	  		|	```TreeMap<K,V>``` | |
| Liste chaînée	|		| ```LinkedList<E>``` |  | ```LinkedList<E>```
| Collection utilisant une table de hashage |  		| ```HashSet<E>``` | ```HashMap<K,V>``` |

* `Set` : collection d'éléments non ordonnés par défaut qui n'accepte pas les doublons
* `List` : collection d'éléments ordonnés qui accepte les doublons
* `Map` : collection sous la forme d'une association de paires clé/valeur
* `Deque` : collections qui stockent des éléments dans un certain ordre avant qu'ils ne soient extraits pour traitement

## Quelques propriétés

|NOM|ORDONNÉE|DOUBLONS|ACCÈS DIRECT|VALEURS NULLES|THREAD-SAFE|
|:--:|:--:|:--:|:--:|:--:|:--:|
|**ArrayList**|✔|✔|✔|✔|❌|
|**HashMap**|❌|❌|✔|✔|❌|
|**HashSet**|❌|❌|❌|✔|❌|
|**LinkedList**|✔|✔|❌|✔|❌|
|**Stack**|✔|✔|❌|✔|✔|
|**TreeMap**|✔|❌|✔|❌|❌|
|**TreeSet**|✔|❌|❌|❌|❌|
|**Vector**|✔|✔|✔|✔|✔|

## L'interface ```Collection<E>``` (suite)
* Cette interface représente un minimum commun pour les objets qui gèrent des collections

| Méthode | Description |
| --- | --- |
| ```boolean add(E e)``` | ajoute l'élément fourni en paramètre à la collection. La valeur de retour indique si la collection a été mise à jour.|
| ```boolean addAll(Collection<? extends E> c)``` |ajoute à la collection tous les éléments de la collection fournie en paramètre.|
| ```void clear()``` | supprime tous les éléments de la collection.|
| ```boolean contains(Object)``` | indique si la collection contient au moins un élément identique à celui fourni en paramètre.|
| ```boolean containsAll(Collection<?> c)``` | indique si tous les éléments de la collection fournie en paramètre sont contenus dans la collection.|

## L'interface ```Collection<E>```
* Cette interface représente un minimum commun pour les objets qui gèrent des collections

| Méthode | Description |
| --- | --- |
| ```boolean isEmpty()``` | indique si la collection est vide.|
| ```Iterator<E> iterator()``` | renvoie un objet qui permet de parcourir l'ensemble des éléments de la collection. |
| ```boolean remove(Object o)``` | supprime l'élément fourni en paramètre.|
| ```boolean removeAll(Collection<?> c)``` |	supprime tous les éléments de la collection qui sont contenus dans la collection fournie en paramètre.|
| ```int size()``` | renvoie le nombre d'éléments contenu dans la collection.|
| ```Object[] toArray()``` | renvoie un tableau d'objets qui contient tous les éléments de la collection.|

## Méthodes optionnelles

* Il existe plein de sortes de collections
  * collections de taille fixe,
  * collections dont on ne peut enlever des objets
  * ....
* Plutôt que de fournir une interface pour chaque cas particulier, l'API sur les collections
comporte la notion de méthode optionnelle

## Méthodes optionnelles

* Lorsqu'une méthode n'est pas définie elle lève l'exception ```UnsupportedOperationException```
* Les méthodes optionnelles renvoient cette exception dans les classes abstraites du paquetage
* Ex : pour des listes non modifiables, on ne redéfinit pas les méthodes ```set``` , ```add``` et ```remove``` de la classe squelette `AbstractList`

## Méthodes optionnelles

```java
ArrayList<String> list = new ArrayList<>();
List<String> list2 = Collections.unmodifiableList(list);
list2.add("hello"); // Lève une exception UnsupportedOperationException
list.add("hello"); list.add("world"); // ok
Systeme.out.println(list2.size);      // affiche 2
```

## Les différentes ```Collection<E>```
Il existe plusieurs implémentations de ```Collection<E>```.
* Les classes [```ArrayList<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html) (tableau de taille variable) et [```LinkedList<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html) (liste chainée) qui  implémentent l'interface ```List<E>```  ;
* La classe [```HashSet<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/HashSet.html) implémente l'interface [```Set<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/Set.html) ;
* La classe [```TreeSet<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/TreeSet.html)  implémente l'interface [```SortedSet<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/SortedSet.html) ;
* ...

## L'interface ```Map<K,V>```

* L'interface [```Map<K,V>```](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html) correspond à un groupe de couples clé-valeur<br>
* Une clé repère une et une seule valeur<br>
* Dans la map il ne peut exister 2 clés égales au sens de ```equals()```<br>
* La même valeur peut-être présente dans deux clés différentes
* Permettent de retrouver rapidement une valeur en fonction de leur clé
* Utilisé pour les dictionnaires, les annuaires ....

## Les méthodes de ```Map<K,V>```
| Méthode | Description |
| --- | --- |
| ```void clear()``` | supprime les éléments de la table associative |
| ```boolean containsKey(Object clé)``` | teste si l'objet passé en paramètre correspond à une clé de la table |
| ```boolean containsValue(Object valeur)``` | teste si l'objet passé en paramètre correspond à une valeur dans la table |
| ```V get(Object clé)``` | retourne la valeur associée à la clé passée en paramètre ou ```null``` si cette clé n'existe pas |
| ```boolean isEmpty()``` | teste si la table est vide |
| ```Set<K> keySet()``` | retourne un objet représentant la liste des clés contenues dans la table associative |
| ```Collection<V> values()``` | retourne un objet contenant toute les valeur contenue dans la table associative |

## Les méthodes de ```Map<K,V>```
| Méthode | Description |
| --- | --- |
| ```put(K clé, V valeur)``` | Ajoute la clé et la valeur dans la collection en retournant la valeur insérée. Si la clé existe déjà, sa valeur sera écrasée par celle passée en paramètre de la méthode. |
| ```putAll(Map<? extends K,? extends V> m)``` | Ajoute le contenu de la collection en paramètre dans la collection appelante |
| ```remove(Object clé)``` | Supprime le couple clé-valeur associé à la clé passée en paramètre et retourne la valeur supprimée |

## Les différentes ```Map<K,V>```

Il y 4 implantations principales des ```Map<K,V>``` :

1. [```HashMap<K,V>```](https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html) table d'association. Pas d'ordre sur les clés et les valeurs.
2. [```TreeMap<K,V>```](https://docs.oracle.com/javase/8/docs/api/java/util/TreeMap.html) arbre rouge et noir, ordonné sur la clé.
3. [```LinkedHashMap<K,V>```](https://docs.oracle.com/javase/8/docs/api/java/util/LinkedHashMap.html) conserve l'ordre d'insertion.
4. [```HashTable<K,V>```](https://docs.oracle.com/javase/8/docs/api/java/util/Hashtable.html) synchronisée par rapport à  ```HashMap<K,V>```.

## Fonctionnement d'une `Map` (`HashMap`, `TreeMap` ...)

Java procède en deux étapes :

* Étape 1 : Calcule le `hashCode()` pour déterminer dans quel bucket (emplacement référencé par la clé) placer l’objet.
* Étape 2 : Si plusieurs objets tombent dans le même bucket, Java utilise `equals()` pour vérifier s’ils sont vraiment égaux.

**Règle fondamentale** :
* Si deux objets sont égaux selon `equals()` alors ils doivent avoir le même `hashCode()`.
`a.equals(b)  =>  a.hashCode() == b.hashCode()`. Sinon les collections basées sur le hash ne fonctionneront pas correctement.

## Exemple problèmatique

```Java
class Personne {
    String name;

Person(String name){
        this.name = name;
    }

public boolean equals(Object o){
	if (this == o) return true;
        if (!(o instanceof Personne)) return false;

Personne p = (Personne) o;
        return name.equals(p.name);
    }
}
// Etc
HashSet<Personne> set = new HashSet<>();

set.add(new Personne("Alice"));
set.add(new Personne("Alice"));

System.out.println(set.size());
```
Résutat : 2 ! `hashCode()` n'a pas été redéfini.

## Implémentation correcte
```Java
class Personne {

String name;

public boolean equals(Object o) {

if (this == o) return true;
        if (!(o instanceof Personne)) return false;

Person p = (Person) o;
        return name.equals(p.name);
    }

public int hashCode() {
        return name.hashCode();
    }
}
```
*Toujours redéfinir les deux ensemble.*

# Parcourir une collection

## Différents parcours

Il existe 3 façons de parcourir une collection :

1. En utilisant un `Iterator`
2. Avec une boucle `for-each`
3. Depuis Java 1.8 en utilisant un `stream`

## Les itérateurs
* Un itérateur est une instance d'une classe qui implante
l'interface [```Iterator<E>```](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)
* Ils permettent d'énumérer les éléments contenus dans une collection
* Ils encapsulent la structure de la collection
  * on pourrait changer de type de collection  sans modifier le code qui utilise l'itérateur
* Toutes les collections ont une méthode ```iterator()``` qui renvoie un itérateur

## L'interface ```Iterator<E>```
Méthode  | Action
--|--
`boolean hasNext()`  | indique s'il reste au moins un élément
`E next()` | renvoie le prochain élément de la collection
`void remove()` | supprime le dernier élément **parcouru** <br>Méthode optionnelle

## Obtenir un itérateur
* ```Iterator<E> iterator()``` renvoie un itérateur pour parcourir les
éléments de la collection
* L'interface ```List<E>``` contient en plus la méthode ```ListIterator<E> listIterator()```
qui renvoie un ```ListIterator```
  * offre plus de possibilités qu'```Iterator``` pour parcourir une liste et la modifier
	* Possibilité de parcourir la liste dans les deux sens, c'est-à-dire en avant et en arrière.
* Avec un `Iterator` votre code fonctionne que vous passiez une `List` ou un `Set` en paramétre (vous travaillerez avec une collection). `ListIterator` ne fonctionne qu'avec `List`.

## Exemple
```
import java.awt.Color;
import java.util.ArrayList;
import java.util.Iterator;

abstract class Forme<T extends Number> {
	abstract double calculAire();

public String toString() {
		return "Aire = " + calculAire();
	}
}

class Cercle<T extends Number> extends Forme<T> {
	T rayon;

Cercle(T r) {
		rayon = r;
	}

double calculAire() {
		return Math.PI * rayon.doubleValue() * rayon.doubleValue();
	}
}

class Carre<T extends Number> extends Forme<T> {
	T cote;

Carre(T c) {
		cote = c;
	}

double calculAire() {
		return cote.doubleValue() * cote.doubleValue();
	}
}

public class TestForme {
	public static void main(String[] s) {
		Forme<Integer> s1 = new Carre(4);
		Forme<Float> s2 = new Carre(5);
		Forme<Double> c1 = new Cercle(3);
		ArrayList<Forme<?>> f = new ArrayList();
		f.add(s1);
		f.add(s2);
		f.add(1, c1);
    	for (Iterator<Forme<?>> it = f.iterator(); it.hasNext();)
			System.out.println(it.next());
	}
}
```

## Exemple
```
import java.util.ArrayList;
import java.util.ListIterator;

public class ExampleListIterator {

public static void main(String[] args) {
    //Créer une ArrayList
    ArrayList arraylist = new ArrayList();

//Ajouter des éléments à l'objet ArrayList
    arraylist.add("Item1");
    arraylist.add("Item2");
    arraylist.add("Item3");
    arraylist.add("Item4");

//Récupérer l'objet de ListIterator avec la méthode listIterator()
    ListIterator listIterator = arraylist.listIterator();

System.out.println("En avant");
    while(listIterator.hasNext())
      System.out.println(listIterator.next());

System.out.println("En arrière");
    while(listIterator.hasPrevious())
      System.out.println(listIterator.previous());
  }
}
```

## Itérateur et modification de la collection
* L'utilisation d'un itérateur sur une collection modifiée directement provoque une `ConcurrentModificationException`
* L'interface Iterator fournit la méthode optionnelle `remove()` qui permet de supprimer le dernier élément retourné par l'itérateur

## Exemple de qu'il ne faut pas faire

```java
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.ListIterator;

public class ConcurrentListModif {
    public static void main(String[] args)
    {
        // Declare ArrayList vide
        ArrayList<String> vt = new ArrayList<String>();

vt.add("Java");
        vt.add("avancé");

// Declare list iterator
        ListIterator<String> listItr = vt.listIterator();

// modification de l'ArrayList => Exception
        vt.add("L2MI");

try {
            // Exception oups
            System.out.println(listItr.next());
        }
        catch (ConcurrentModificationException e) {
            System.out.println("Exception: " + e);
        }
    }
}
```

## Itérateur et modification de la collection

* Pour faire des ajouts/modifs dans une liste (impossible avec une collection qui n'implante pas l'interface `List` ) pendant qu'elle est parcourue par un itérateur, on utilise `ListIterator`.

```java
public class ListIteratorSet {
  public static void main(String[] args) {
    ArrayList <String> informaticiens = new ArrayList <String>();
    informaticiens.add("Charles Babbage");
    informaticiens.add("Noam Chomsky");
    informaticiens.add("Damien Olivier");   // Un peu la grosse tête !
    informaticiens.add("Alonzo Church");
    informaticiens.add("John von Neumann");
    ListIterator <String> listIterator = informaticiens.listIterator();
    while (listIterator.hasNext()) {
      String nom = listIterator.next();
      System.out.println(nom);
      if (nom.equals("Damien Olivier"))
        listIterator.set("Alan Turing");
    }
    System.out.println("Liste après modifications :- ");
    for (Iterator<String> it = informaticiens.iterator(); it.hasNext() ; ) { // il y a mieux comme boucle
      System.out.println(it.next());
    }
  }
}
```

## La boucle `for-each`
* Boucle avec un itérateur :
```
for (Iterator<Forme<?>> it = f.iterator(); it.hasNext();)
      System.out.println(it.next());
```
* Avec un `for-each`
```
for (Forme ff : f)
      System.out.println(ff);
```

## La boucle `for-each`
* `for` (_TypeDev_  `v :` _expression_) _instruction_
*  _TypeDev_  `v ` : déclaration d'une variable
* _expression_ : une expression dont l'évaluation donne un tableau `typeT[]` ou un
objet qui implante `Iterable<E>`, t.q `typeT` ou `E` est affectable à `v`

## Restriction `for-each`

* On ne dispose pas de la position dans le
tableau ou la collection pendant le parcours
* On ne peut pas modifier la collection pendant
qu'on parcourt la collection

# Exemple

## Exemple : utilisation d'un `ArrayList`
```java
import java.util.*;

public class ArrayListExemples {

public static void main(String args[]) {
		// On créée un tableau de String de taille variable
		ArrayList<String> list = new ArrayList<String>();

// Ajout d'éléments dans l'arraylist
		list.add("Item1");
		list.add("Item2");
		list.add(2, "Item3"); // Ajoute l'élément à la 3ème position
		list.add("Item4");

// On affiche le contenu
		System.out.println("L'ArrayList contient : "
				+ list);

// On recherche la position d'un élément
		int pos = list.indexOf("Item2");
		System.out.println("L'index de Item2 est : " + pos);

// On teste si c'est vide
		boolean check = list.isEmpty();
		System.out.println("L'ArrayList est vide : ? " + check);

// Taille
		int size = list.size();
		System.out.println("La taille de l'ArrayList est : " + size);

// On vérifie si un élément est présent
		boolean element = list.contains("Item5");
		System.out.println("Item5 est présent ? : "
						+ element);

// On récupére un élément à une position précise
		String item = list.get(0);
		System.out.println("L'élément d'index 0 est : " + item);

// Parcours

// 1ère façon : boucle avec un indice et la taille de la liste
		System.out.println("Boucle avec un indice et la taille de la liste");
		for (int i = 0; i < list.size(); i++) {
			System.out.println("Index: " + i + " - Élément : " + list.get(i));
		}

// 2ème façon un for-each
		System.out.println("Boucle avec un for-each");
		for (String str : list) {
			System.out.println("Élément : " + str);
		}

// 3ème façon : un iterateur
		System.out.println("Boucle avec un itérateur");
		for (Iterator<String> it = list.iterator(); it.hasNext();) {
			System.out.println("Élément : " + it.next());
		}

// Remplacer un élement
		list.set(1, "Nouvel élément");
		System.out.println("L'ArrayList après remplacement est : " + list);

// Supprimer un élément connaissant sont indice
		list.remove(0);

// Supprimer la première occurrence d'un élément "Item3"
		list.remove("Item3");

System.out.println("Le contenu de l'ArrayList est : " + list);

// Convertir une ArrayList en Array
		String[] simpleArray = list.toArray(new String[list.size()]);
		System.out.println("Le tableau obtenu après la conversion : " + Arrays.toString(simpleArray));
	}
}
```