Java ArrayList : création et uti­li­sa­tion d’une liste

La classe ArrayList est l’une des struc­tures de données les plus souvent utilisées en Java. Elle permet de modifier de manière dynamique et d’en­re­gis­trer un ensemble d’objets. Dans ce tutoriel, nous vous pré­sen­tons la syntaxe et les méthodes relatives à la classe ArrayList de Java.

Quelle est la dif­fé­rence entre les classes ArrayList et Array en Java ?

La classe ArrayList de Java dispose d’une taille dynamique, ce qui signifie que des éléments peuvent être fa­ci­le­ment ajoutés ou supprimés. En outre, la classe ArrayList fait partie du Java Col­lec­tions Framework mais con­trai­re­ment à la classe Array, elle n’est pas native. Vous devez l’importer à partir de la bi­blio­thèque java.util.

L’ArrayList est une méthode ap­pro­priée lorsque la longueur de la liste Java est sus­cep­tible de varier. C’est le cas lors de l’en­re­gis­tre­ment d’objets, de la recherche ou du tri de données, ainsi que de la création de listes ou de files d’attente.

En com­pa­rai­son, la taille du type de données Array n’est pas mo­di­fiable. Le nombre d’objets qu’un array doit en­re­gis­trer doit donc être connu avant la création. La classe Array est donc ap­pro­priée pour la gestion d’une quantité pré­dé­fi­nie de types de données primitifs, comme int, float, char ou boolean.

L’un des in­con­vé­nients de la classe ArrayList est le temps d’accès plus long. Alors qu’avec un Array, un espace de stockage fixe est réservé, ce n’est pas le cas avec un ArrayList. Il est donc important de tenir compte des avantages et des in­con­vé­nients res­pec­tifs de ces deux classes et de choisir la structure de données ap­pro­priée à l’usage cor­res­pon­dant.

Syntaxe de Java ArrayList

Avant la création d’un ArrayList, la classe cor­res­pon­dante doit d’abord être importée depuis la bi­blio­thèque java.util.

import java.util.ArrayList;

La syntaxe générale est la suivante :

ArrayList<Type> arrayList= new ArrayList<>();

Ici, « Type » cor­res­pond au type de données respectif de l’ArrayList Java.

Ensuite, nous créons des listes de chaînes de ca­rac­tères (« String ») et d’entiers (« Integer »).

ArrayList<String> arrayList= new ArrayList<>();

ArrayList<Integer> arrayList= new ArrayList<>();

Les ArrayList utilisent les classes en­ve­loppes cor­res­pon­dantes des types de données primitifs afin que ces dernières puissent être traitées comme des objets. C’est la raison pour laquelle nous devons saisir « Integer » et non « int ».

Exemples de méthodes Java ArrayList

Avec la classe ArrayList, les opé­ra­tions telles que l’ajout ou la sup­pres­sion d’éléments ne sont pas exécutées avec des opé­ra­teurs Java, mais avec des méthodes pré­dé­fi­nies. Nous vous pré­sen­tons ci-après les méthodes ArrayList les plus courantes.

Ajouter des éléments

Une fois que l’ArrayList « colors », de type « String », a été créé, nous ajoutons divers éléments à l’aide de la méthode « .add() ».

import java.util.ArrayList;
class Main {
    public static void main(String[] args){
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
    }
}

Le résultat est le suivant :

ArrayList: [blue, red, green]

Supprimer des éléments

Pour supprimer des objets d’un ArrayList Java, nous utilisons la méthode « .remove() » complétée de l’in­di­ca­teur numérique des éléments à supprimer.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
        String color = colors.remove(1);
        System.out.println("ArrayList: " + colors);
        System.out.println("Removed Element: " + color);
    }
}

Le résultat affiche l’ArrayList modifié, ainsi que l’élément supprimé :

ArrayList : [blue, green]
Removed Element: red

Comme dans la majorité des langages de pro­gram­ma­tion, en Java, le décompte débute à partir de la position 0. C’est pourquoi l’élément supprimé est la valeur « red » qui cor­res­pond à l’in­di­ca­teur 1.

Accéder aux éléments d’un Java ArrayList

Grâce à la fonction « .get() », nous accédons à un élément situé à une position spé­ci­fique.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> clothes = new ArrayList<>();
        clothes.add("jacket");
        clothes.add("shirt");
        clothes.add("pullover");
        System.out.println("ArrayList: " + clothes);
        String str = clothes.get(2);
        System.out.print("Element at index 2: " + str);
    }
}

Le résultat est le suivant :

ArrayList: [jacket, shirt, pullover]
Element at index 2: pullover

Modifier des éléments

Grâce à « .set() », nous dé­fi­nis­sons un nouvel élément à une position spé­ci­fique.

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println("ArrayList: " + colors);
        colors.set(2, "yellow");
        System.out.println("Modified ArrayList: " + colors);
    }
}

Dans le résultat, nous lisons à présent « yellow » en position 2 et non plus « green ».

ArrayList: [blue, red, green]
Modified ArrayList: [blue, red, yellow]

Dé­ter­mi­ner la longueur d’un Java ArrayList

Le nombre d’éléments composant un ArrayList est fa­ci­le­ment calculé grâce à la méthode « .size() ».

import java.util.ArrayList;
class Main {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        System.out.println(colors.size());
    }
}

Le résultat est le suivant :

3

Trier et itérer via un ArrayList

Pour trier un ArrayList Java, vous devez importer la classe Col­lec­tions. Pour l’itération, nous utilisons une boucle Java for-each. À chaque exécution de la boucle, l’élément cor­res­pon­dant est indiqué à l’écran.

import java.util.ArrayList;
import java.util.Collections;
public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> ages = new ArrayList<Integer>();
        ages.add(20);
        ages.add(54);
        ages.add(17);
        ages.add(9);
        Collections.sort(ages);
        for (int i : ages) {
            System.out.println(i);
        }
    }
}

Les éléments de l’ArrayList sont restitués dans l’ordre croissant :

9
17
20
54