Docs Java exécutables : ArrayList

Q: Comment supprimer un élément d'une ArrayList ?

Appelez remove(index) pour supprimer par position, ou remove(object) pour supprimer le premier élément correspondant. Attention avec les listes d'Integer : list.remove(2) supprime l'indice 2, tandis que list.remove(Integer.valueOf(2)) supprime la valeur 2. Pour supprimer pendant un parcours, utilisez le remove() d'un Iterator ou removeIf(...) afin d'éviter une ConcurrentModificationException.

Une liste qui se redimensionne toute seule

Un simple tableau Java a une longueur fixe : décidez de dix emplacements et vous aurez dix emplacements pour toujours. ArrayList est l'alternative redimensionnable de java.util - elle grandit quand vous ajoutez et rétrécit quand vous supprimez, et elle embarque des méthodes pratiques pour ce que vous faites réellement avec une liste.

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

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ada");
        names.add("Boris");
        names.add("Chen");

        System.out.println(names);
        System.out.println("Count: " + names.size());
    }
}

Remarquez le type entre chevrons - List<String> - qui indique au compilateur que cette liste contient des valeurs String. Le <> (le « diamant ») à droite permet à Java de déduire le même type sans le répéter. Et notez que vous importez java.util.ArrayList ; elle n'est pas disponible par défaut.

Déclarer en List, construire en ArrayList

Vous verrez presque toujours la variable déclarée avec l'interface List plutôt qu'avec l'ArrayList concrète :

List<String> names = new ArrayList<>();

C'est une bonne habitude, pas une règle. Programmer pour l'interface List signifie que le reste de votre code ne se soucie pas de l'implémentation de liste utilisée, ce qui vous permet d'en changer plus tard sans y toucher. Pour un usage quotidien, les deux se comportent de la même manière.

Ajouter, lire et modifier

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");      // ajoute à la fin
        fruits.add("banana");
        fruits.add(1, "cherry");  // insère à l'indice 1

        System.out.println(fruits.get(0));   // lit par indice
        fruits.set(0, "apricot");            // écrase l'indice 0

        System.out.println(fruits);
    }
}

add(value) ajoute à la fin.
add(index, value) insère à une position, décalant les éléments suivants vers la droite.
get(index) lit l'élément à une position (en commençant à zéro).
set(index, value) écrase un élément existant.

Les indices commencent à zéro, et get sur un indice hors limites lève IndexOutOfBoundsException.

Supprimer des éléments

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();
        fruits.add("apple");
        fruits.add("banana");
        fruits.add("cherry");

        fruits.remove("banana");  // supprime par valeur (première correspondance)
        fruits.remove(0);         // supprime par indice

        System.out.println(fruits);
    }
}

Il existe un piège classique quand la liste contient des Integer. remove(int) signifie « supprimer par indice » et remove(Object) signifie « supprimer par valeur », donc :

List<Integer> nums = new ArrayList<>(List.of(10, 20, 30));
nums.remove(1);                      // supprime l'indice 1 -> la valeur 20
nums.remove(Integer.valueOf(20));    // supprime la valeur 20

Enveloppez la valeur dans Integer.valueOf(...) lorsque vous voulez dire « supprime cette valeur », et non « supprime cet indice ».

Taille, contains et recherches d'indice

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        System.out.println(fruits.size());            // 3
        System.out.println(fruits.isEmpty());         // false
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("cherry"));  // 2
    }
}

List.of(...) construit rapidement une liste immuable ; la passer au constructeur d'ArrayList vous donne une copie modifiable initialisée avec ces valeurs.

Parcourir une ArrayList

La boucle la plus propre est le for amélioré (le « for-each ») :

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (String fruit : fruits) {
            System.out.println(fruit.toUpperCase());
        }
    }
}

Quand vous avez aussi besoin de l'indice, utilisez une boucle comptée avec size() et get(i) :

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>(List.of("apple", "banana", "cherry"));

        for (int i = 0; i < fruits.size(); i++) {
            System.out.println(i + ": " + fruits.get(i));
        }
    }
}

Une règle : n'ajoutez ni ne supprimez d'éléments d'une liste pendant qu'une boucle for-each la parcourt - cela lève ConcurrentModificationException. Pour supprimer en toute sécurité les éléments correspondants, utilisez removeIf :

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

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(1, 2, 3, 4, 5, 6));
        nums.removeIf(n -> n % 2 == 0);   // retire les nombres pairs
        System.out.println(nums);
    }
}

Trier

Collections.sort ordonne une liste sur place selon l'ordre naturel (alphabétique pour les chaînes, numérique pour les nombres) :

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>(List.of(3, 1, 4, 1, 5, 9, 2, 6));

        Collections.sort(nums);
        System.out.println(nums);

        nums.sort(Collections.reverseOrder());  // décroissant
        System.out.println(nums);
    }
}

Pour des ordres personnalisés, passez un Comparator à list.sort(...) - par exemple names.sort(Comparator.comparingInt(String::length)) pour trier par longueur.

ArrayList contient des objets, pas des primitifs

Vous ne pouvez pas écrire ArrayList<int>. Les génériques ne fonctionnent qu'avec des types objet, alors utilisez la classe enveloppe Integer, Double, Boolean, etc. :

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

public class Main {
    public static void main(String[] args) {
        List<Integer> scores = new ArrayList<>();
        scores.add(95);   // l'int 95 est auto-boxé en Integer
        scores.add(88);

        int first = scores.get(0);  // auto-déboxé en int
        System.out.println(first + scores.get(1));
    }
}

L'autoboxing de Java convertit pour vous entre int et Integer, ce qui rend ce code naturel à lire - souvenez-vous simplement que la liste elle-même stocke des objets Integer.

Suite : HashMap

ArrayList est l'outil adapté lorsque l'ordre et la position vous importent. Quand vous devez retrouver des éléments par une clé - un nom d'utilisateur vers un utilisateur, un code produit vers un prix - vous voulez une HashMap, qui fait l'objet de la page suivante.

Questions fréquentes

Comment créer une ArrayList en Java ?

Déclarez-la avec le type des éléments entre chevrons et appelez le constructeur : ArrayList<String> names = new ArrayList<>();. Le <> à droite (le diamant) permet à Java de déduire le type. On déclare généralement la variable avec l'interface List : List<String> names = new ArrayList<>();.

Quelle est la différence entre un tableau et une ArrayList en Java ?

Un simple tableau a une longueur fixe définie à sa création et peut contenir des primitifs comme int. Une ArrayList grandit et rétrécit automatiquement à mesure que vous ajoutez et supprimez des éléments, ne contient que des objets (donc int devient Integer) et fournit des méthodes comme add, remove, contains et size. Utilisez un tableau pour des données primitives de taille fixe ; utilisez une ArrayList lorsque la taille change.

Comment supprimer un élément d'une ArrayList ?

Appelez remove(index) pour supprimer par position, ou remove(object) pour supprimer le premier élément correspondant. Attention avec les listes d'Integer : list.remove(2) supprime l'indice 2, tandis que list.remove(Integer.valueOf(2)) supprime la valeur 2. Pour supprimer pendant un parcours, utilisez le remove() d'un Iterator ou removeIf(...) afin d'éviter une ConcurrentModificationException.

Concepts liés

ArrayList en Java : créer, ajouter, supprimer, parcourir et trier