Description

ArrayList est une implémentation de l'inetrface List. Elle repose sur un tableau interne, offrant un temps d'accès rapide aux éléments, mais des opérations d'insertion et de suppression plus lentes. Cette classe n'est pas thread-safe, nécessitant une synchronisation externe dans un contexte multithread.

Exemple d'utilisation

Voici une classe Eleve modélisant un étudiant avec un nom et un âge, suivie d'une démonstration avec ArrayList.

class Eleve {
    private String nom;
    private Integer age;

    public Eleve() {
    }

    public Eleve(String nom, Integer age) {
        this.nom = nom;
        this.age = age;
    }

    public String getNom() {
        return nom;
    }

    public Integer getAge() {
        return age;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    @Override
    public String toString() {
        return "Eleve{" +
                "nom='" + nom + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        Eleve autre = (Eleve) o;
        return Objects.equals(nom, autre.nom) && Objects.equals(age, autre.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(nom, age);
    }
}

package com.example.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

public class ExempleArrayList {
    public static void main(String[] args) {
        ArrayList<object> collection = new ArrayList<>();

        Eleve e1 = new Eleve("Alice", 20);
        Eleve e2 = new Eleve("Bob", 22);
        Eleve e3 = new Eleve("Charlie", 21);

        collection.add(e1);
        collection.add(e2);
        collection.add(e3);
        collection.add(e3);
        System.out.println(collection);

        collection.remove(new Eleve("Bob", 22));
        System.out.println(collection);

        System.out.println("==========Itération avec Iterator==========");
        Iterator iter = collection.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }

        System.out.println("==========Itération avec ListIterator==========");
        ListIterator iterListe = collection.listIterator();
        while (iterListe.hasNext()) {
            System.out.println(iterListe.next());
        }

        System.out.println("==========Itération inverse avec ListIterator==========");
        while (iterListe.hasPrevious()) {
            System.out.println(iterListe.previous());
        }

        System.out.println(collection.isEmpty());
        System.out.println(collection.contains(new Eleve("Charlie", 21)));
        System.out.println(collection.indexOf(new Eleve("Charlie", 21)));
    }
}
</object>

Analyse du code source

Examinons les mécanismes internes d'ArrayList, notamment la gestion de la capacité et des opérations de modification.

La structure est basée sur un tableau avec une capacité initiale de 10. Lorsque le nombre d'éléments dépasse cette capacité, le tableau est agrandi automatiquement, sans réduction automatique. Pour réduire la taille, il faut appeler explicitement une méthode dédiée.

Attributs clés :

private static final int CAPACITE_INITIALE = 10;
transient Object[] elements; // Stockage des éléments
private int taille; // Nombre d'éléments courants

Méthode d'ajout :

public boolean ajouter(E element) {
    verifierCapaciteInterne(taille + 1);
    elements[taille++] = element;
    return true;
}

private void verifierCapaciteInterne(int capaciteMin) {
    verifierCapaciteExplicite(calculerCapacite(elements, capaciteMin));
}

private static int calculerCapacite(Object[] elements, int capaciteMin) {
    if (elements == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(CAPACITE_INITIALE, capaciteMin);
    }
    return capaciteMin;
}

private void verifierCapaciteExplicite(int capaciteMin) {
    modCount++;

    if (capaciteMin - elements.length > 0)
        agrandir(capaciteMin);
}

private void agrandir(int capaciteMin) {
    int ancienneCap = elements.length;
    int nouvelleCap = ancienneCap + (ancienneCap >> 1);
    if (nouvelleCap - capaciteMin < 0)
        nouvelleCap = capaciteMin;
    if (nouvelleCap - MAX_ARRAY_SIZE > 0)
        nouvelleCap = capaciteExtreme(capaciteMin);
    elements = Arrays.copyOf(elements, nouvelleCap);
}

Méthode de suppression :

public E supprimer(int index) {
    verifierPlage(index);

    modCount++;
    E ancienneValeur = elementData(index);

    int nbDeplacer = taille - index - 1;
    if (nbDeplacer > 0)
        System.arraycopy(elements, index+1, elements, index, nbDeplacer);
    elements[--taille] = null;

    return ancienneValeur;
}

Méthode de réduction de taille :

public void ajusterTaille() {
    modCount++;
    if (taille < elements.length) {
        elements = (taille == 0)
            ? EMPTY_ELEMENTDATA
            : Arrays.copyOf(elements, taille);
    }
}