Utilisation de ArrayList en Java

ArrayList est un tableau dynamique qui implémente l'interface List. L'utilisateur de cette interface a le contrôle total sur les éléments insérés et y accède par position ainsi que la recherche des éléments dans la liste.

ArrayList implémente toutes les méthodes de List, plus que ça, la classe a ses propres méthodes comme la manipulation de la taille du tableau utilisé pour stocker la liste. Cette classe est équivalente à Vector.
Arraylist utilise un tableau qui stocke les données, ce tableau a une capacité qui s'adapte automatiquement à chaque fois qu'un élément est inséré. Il existe une méthode ensureCapacity qui augmente la capacité de ArrayList avant d'ajouter un grand nombre éléments pour assurer la taille.

L’accès à la liste se fait simultanément par plusieurs threads. Cela peut causer des problèmes quand il s'agit d'une modification, insertion ,suppression parce qu'un autre thread va accéder et mit à jour de la taille de la liste est en cours. La solution est la synchronisation des processus en utilisant la méthode Collections.synchronizedList.

List list = Collections.synchronizedList(new ArrayList(...));

Pour parcourir la liste avec la classe iterator ou listIterator, mais si la liste a été modifiée : suppression, insertion...après la création de iterator, ce dernier va lancer une exception ConcurrentModificationException. La solution est de créer une exclusion mutuelle dont le but est d’empêcher les autres threads d y accéder après la création de iterator et pendant la lecture.

Les constructeurs

ArrayList a trois constructeur:

- ArrayList(): crée une liste vide avec une taille initiale de 10.
- ArrayList(Collection<? extends E> c): crée une liste à partir d'une collection de données et renvoie une exception NullPointerException si la collection est nulle.
- ArrayList(int capacite): crée une liste en définissant la taille initiale et renvoie une exception IllegalArgumentException si la taille est négative.

Les méthodes

1) add(Object o): ajoute un élément à la fin.
list.add("Bonjour");

2) add(int indice, Object o): Insertion au milieu.
list.add(3, "e");
Elle insère la chaîne de caractères String dans la troisième position.

3) addAll(Collection c): Ajoute une collection.
ArrayList l1 = new ArrayList();
l1.add("mot");
l1.add(12);
l1.add(10.4f);
list.addAll(l1);
Cette méthode ajoute une autre liste l1 à la fin de la liste list.

4) addAll(int indice, Collection c): Ajoute une collection au milieu.
list.addAll(3, l1);
Insertion de la liste l1 dans la position 3. Les autres éléments qui ont un indice supèrieur à 3 seront décalés.

5) clear(): Supprimer tous les éléments.

6) contains(Object o): Appartenance d'un élément.
boolean b = list.contains(o)
La valeur de b vaut true si l'objet o appartient à la liste.

8) ensureCapacity(int capacite): augmente la capacité, elle assure qu'elle peut contenir un nombre d'éléments avec sa capacité minimal.
list.ensureCapacity(10);
Ceci va augmenter la capacité avec 10 éléments.

9) get(int indice): retourne l'objet à une position.
system.out.println(list.get(2));
Cette fonction affiche le deuxième objet stocké dans la liste.

10) indexOf(Object o): Retourne l'indice d'un élément.
int k = indexOf("o4");
La variable entier k va recevoir l'indice de la première occurrence de l'objet o4. On a dit bien juste la première occurrence.

11) isEmpty(): Retourne true si la liste est vide.
boolean b = list.isEmpty();
Si la liste est vide b est true.

12) remove(Object o): supprime la première occurrence de l'objet o.
boolean b = list.remove("o4");
Retourne true si l'objet existe et a été supprimé avec succès.

13) removeAll(Collection<?> c): supprime les éléments qui sont dans la collection passé en argument.
AarrayList<String> lc = new ArrayList<String>();
lc .add("o1");
lc .add("o2");
lc .add("o3");
list.removeAll(lc);
Elle cherche les éléments et les supprime.

14) removeRange( int début, int fin): supprime les éléments qui se situent entre l'indice début et l'indice fin.
list.removeRange(3,8);
Cette procédure supprime les éléments entre 3 et 8.

15) retainsAll(Collection<?> c): garde seulement les éléments qui sont dans la collection c.

16) set(int indice, Object o): modifie l'objet dans un position spécifique.
list.set(3, "o5");
L'objet dans la position 3 a été remplacé par o5.

17) size(): retourne le nombre d'éléments.

18) subList(int début, int fin): retourne le fragment situé entre le début et la fin.

19) toArray(): retourne un tableau d'une dimension.
String[] t = list.toArray();
Le tableau t contient tous les objets de list. Cette méthode est utile lorsque on a une fonction qui n'accepte que les tableaux par exemple.

20) trimToSize(): réduit la capacité de stockage au niveau maximum.

Comment parcourir un ArrayList

On peut parcourir un ArrayList avec deux méthodes:

1) Boucle for

for(int i = 0; i < list.size(); i++)
    system.out.println(list.get(i));
ou par exemple si on connait le type:
for(Integer nombre : list)
    system.out.println(nombre);

2) Iterator + While

Iterator itr = list.iterator();
while(itr.hasNext())
      system.out.println(itr.next());

Exemple

import java.util.ArrayList;

public class Test {

 public static void main(String[] args) {
 
 //créer un arraylist avec une capacité initiale de 4
 ArrayList str = new ArrayList(4);

 //Ajout
 str.add("o1");
 str.add("o2");
 str.add("o3");
 str.add("o4");
 
 //Quelques méthodes qu'on a vu
 System.out.println("indice de "+"o2: "+str.indexOf("o2"));
 System.out.println("o3 existe ? "+str.contains("o3"));
 System.out.println("o2 supprimé avec succès: "+str.remove("o2"));
 System.out.println("taille: "+str.size());
 System.out.println("[1, 3] : "+str.subList(1, 3));
 
 //parcours
 for(String s : str)
 System.out.println(s);
 
 str.clear();
 System.out.println("liste est vide ? "+str.isEmpty());
 
 }
}
Références:
javadoc: ArrayList