Java ArrayList : création et utilisation d’une liste

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

Quelle est la diffé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 facilement ajoutés ou supprimés. En outre, la classe ArrayList fait partie du Java Collections Framework mais contrairement à la classe Array, elle n’est pas native. Vous devez l’importer à partir de la bibliothèque java.util.

L’ArrayList est une méthode appropriée lorsque la longueur de la liste Java est susceptible de varier. C’est le cas lors de l’enregistrement 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 comparaison, la taille du type de données Array n’est pas modifiable. Le nombre d’objets qu’un array doit enregistrer doit donc être connu avant la création. La classe Array est donc appropriée pour la gestion d’une quantité prédéfinie de types de données primitifs, comme int, float, char ou boolean.

L’un des inconvé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 inconvénients respectifs de ces deux classes et de choisir la structure de données appropriée à l’usage correspondant.

Syntaxe de Java ArrayList

Avant la création d’un ArrayList, la classe correspondante doit d’abord être importée depuis la bibliothèque java.util.

import java.util.ArrayList;

La syntaxe générale est la suivante :

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

Ici, « Type » correspond au type de données respectif de l’ArrayList Java.

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

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

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

Les ArrayList utilisent les classes enveloppes correspondantes 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érations telles que l’ajout ou la suppression d’éléments ne sont pas exécutées avec des opérateurs Java, mais avec des méthodes prédéfinies. Nous vous présentons 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’indicateur 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 programmation, en Java, le décompte débute à partir de la position 0. C’est pourquoi l’élément supprimé est la valeur « red » qui correspond à l’indicateur 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écifique.

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éfinissons un nouvel élément à une position spécifique.

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éterminer la longueur d’un Java ArrayList

Le nombre d’éléments composant un ArrayList est facilement 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 Collections. Pour l’itération, nous utilisons une boucle Java for-each. À chaque exécution de la boucle, l’élément correspondant 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