Classe Java ArrayList

le ArrayList class est une implémentation de List interface qui nous permet de créer des tableaux redimensionnables.

The Java ArrayList class implements the List interface.


Tableau Java vs ArrayList

En Java, nous devons déclarer la taille d’un tableau avant de pouvoir l’utiliser. Une fois la taille d’un tableau déclarée, il est difficile de la modifier.

Pour gérer ce problème, nous pouvons utiliser le ArrayList classe. le ArrayList classe présente dans le java.util package nous permet de créer des tableaux redimensionnables.

Contrairement aux tableaux, les listes de tableaux (objets du ArrayList class) peut ajuster automatiquement sa capacité lorsque nous y ajoutons ou en supprimons des éléments. Par conséquent, les listes de tableaux sont également appelées tableaux dynamiques.


Créer une ArrayList

Voici comment nous pouvons créer des listes de tableaux en Java:

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

Ici,Typeindique le type d’une liste de tableaux. Par exemple,

 // create Integer type arraylist
ArrayList<Integer> arrayList = new ArrayList<>();

// create String type arraylist
ArrayList<String> arrayList = new ArrayList<>();
 

Dans le programme ci-dessus, nous avons utilisé Integer et String . Ici, Integer est la classe wrapper correspondante du int type.

Une classe wrapper est une classe qui encapsule un type de données primitif. Par exemple, le Integer classe encapsule le int tapez le Float classe encapsule le float type, etc.

Remarque:Nous ne pouvons pas créer de listes de tableaux de types de données primitifs comme int ,  float ,  char , etc. À la place, nous devons utiliser leur classe wrapper correspondante.

Dans le cas des chaînes, String est une classe et n’a pas de classe wrapper. Par conséquent, nous avons utilisé String tel quel.


Nous pouvons également créer des listes de tableaux en utilisant le List interface. C’est parce que le ArrayList classe implémente le List interface.

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

Méthodes de ArrayList

 ArrayList fournit diverses méthodes qui nous permettent d’effectuer des opérations de liste de tableaux.


Ajouter des éléments à une ArrayList

1. Utilisation de la méthode add ()

Pour ajouter un seul élément à la liste des tableaux, nous utilisons le add() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args){
        ArrayList<String> animals = new ArrayList<>();

        // Add elements
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayList: " + animals);
    }
}
 

Production

ArrayList: [Chien, Chat, Cheval]

2. Utilisation du numéro d’index

Nous pouvons également ajouter des éléments à une liste de tableaux à l’aide d’index. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args){
        ArrayList<String> animals = new ArrayList<>();

        // Add elements
        animals.add(0,"Dog");
        animals.add(1,"Cat");
        animals.add(2,"Horse");
        System.out.println("ArrayList: " + animals);
    }
}
 

Production

ArrayList: [Chien, Chat, Cheval]

3. Ajouter des éléments d’une liste de tableaux à une autre liste de tableaux

Pour ajouter tous les éléments d’une liste de tableaux à une nouvelle liste de tableaux, nous utilisons le addAll() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args){
        ArrayList<String> mammals = new ArrayList<>();
        mammals.add("Dog");
        mammals.add("Cat");
        mammals.add("Horse");
        System.out.println("Mammals: " + mammals);

        ArrayList<String> animals = new ArrayList<>();
        animals.add("Crocodile");

        // Add all elements of mammals in animals
        animals.addAll(mammals);
        System.out.println("Animals: " + animals);
    }
}
 

Production

Mammifères: [Chien, Chat, Cheval]
Animaux: [Crocodile, Chien, Chat, Cheval]

Initialiser un ArrayList à l’aide de asList ()

Contrairement aux tableaux, nous ne pouvons pas initialiser directement les listes de tableaux. Cependant, nous pouvons utiliser le asList() méthode de la Arrays classe pour obtenir le même effet.

Afin d’utiliser le asList() méthode, il faut importer la java.util.Arrays paquet en premier.

Par exemple,

 import java.util.ArrayList;
import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        // Creating an array list
        ArrayList<String> animals = new ArrayList<>(Arrays.asList("Cat", "Cow", "Dog"));
        System.out.println("ArrayList: " + animals);

        // Access elements of the array list
        String element = animals.get(1);
        System.out.println("Accessed Element: " + element);
    }
}
 

Production

ArrayList: [Chat, Vache, Chien]
Élément consulté: vache

Dans l’exemple ci-dessus, notez l’expression,

 new ArrayList<>(Arrays.asList(("Cat", "Cow", "Dog"));
 

Ici, nous avons d’abord créé un tableau de 3 éléments:« Chat », « Vache », et« Chien ». Puis le asList() est utilisée pour convertir le tableau en une liste de tableaux.

Pour en savoir plus sur les différentes manières d’initialiser un ArrayList , visitez: Initialisation d’une ArrayList en une seule ligne


Accéder aux éléments ArrayList

1. Utilisation de la méthode get ()

Pour accéder de manière aléatoire aux éléments d’une liste de tableaux, nous utilisons le get() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals= new ArrayList<>();

        // Add elements in the array list
        animals.add("Dog");
        animals.add("Horse");
        animals.add("Cat");
        System.out.println("ArrayList: " + animals);

        // Get the element from the array list
        String str = animals.get(0);
        System.out.print("Element at index 0: " + str);
    }
}
 

Production

ArrayList: [Chien, Cheval, Chat]
Élément à l'index 0: Chien

2. Utilisation de la méthode iterator ()

Pour accéder séquentiellement aux éléments d’une liste de tableaux, nous utilisons le iterator() méthode. Il faut importer java.util.Iterator package pour utiliser cette méthode. Par exemple,

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

class Main {
    public static void main(String[] args){
        ArrayList<String> animals = new ArrayList<>();

        // Add elements in the array list
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        animals.add("Zebra");

        // Create an object of Iterator
        Iterator<String> iterate = animals.iterator();
        System.out.print("ArrayList: ");

        // Use methods of Iterator to access elements
        while(iterate.hasNext()){
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}
 

Production

ArrayList: chien, chat, cheval, zèbre,

Remarque:

  •  hasNext() Retour true s’il y a un élément suivant dans la liste des tableaux.
  •  next() renvoie l’élément suivant dans la liste des tableaux

Modifier les éléments ArrayList

Pour changer les éléments d’une liste de tableaux, nous pouvons utiliser le set() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals= new ArrayList<>();
        // Add elements in the array list
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayList: " + animals);

        // Change the element of the array list
        animals.set(2, "Zebra");
        System.out.println("Modified ArrayList: " + animals);
    }
}
 

Production

ArrayList: [Chien, Chat, Cheval]
ArrayList modifié: [Dog, Cat, Zebra]

Supprimer les éléments ArrayList

1. Utilisation de la méthode remove ()

Pour supprimer un élément d’une liste de tableaux, nous pouvons utiliser le remove() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals = new ArrayList<>();

        // Add elements in the array list
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("Initial ArrayList: " + animals);

        // Remove element from index 2
        String str = animals.remove(2);
        System.out.println("Final ArrayList: " + animals);
        System. out.println("Removed Element: " + str);
    }
}
 

Production

ArrayList initiale: [Chien, Chat, Cheval]
ArrayList final: [Chien, Chat]
Élément supprimé: cheval

2. Utilisation de la méthode removeAll ()

Pour supprimer tous les éléments d’une liste de tableaux, nous utilisons le removeAll() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals = new ArrayList<>();

        // Add elements in the ArrayList
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("Initial ArrayList: " + animals);

        // Remove all the elements
        animals.removeAll(animals);
        System.out.println("Final ArrayList: " + animals);
    }
}
 

Production

 Initial ArrayList: [Dog, Cat, Horse]
Final ArrayList: []
 

3. Utilisation de la méthode clear ()

Nous pouvons également utiliser le clear() méthode pour supprimer tous les éléments d’une liste de tableaux. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals= new ArrayList<>();

        // Add elements in the array list
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("Initial ArrayList: " + animals);

        // Remove all the elements
        animals.clear();
        System.out.println("Final ArrayList: " + animals);
    }
}
 

Production

ArrayList initiale: [Chien, Chat, Cheval]
ArrayList finale: []

Remarque:le clear() est plus efficace que la removeAll() méthode.


Boucle à travers une ArrayList

1. Utilisation de la boucle for

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // Creating an array list
        ArrayList<String> animals = new ArrayList<>();
        animals.add("Cow");
        animals.add("Cat");
        animals.add("Dog");
        System.out.println("ArrayList: " + animals);

        // Using for loop
        System.out.println("Accessing individual elements: ");

        for(int i = 0; i < animals.size(); i++) {
            System.out.print(animals.get(i));
            System.out.print(", ");
        }
    }
}
 

Production

ArrayList: [Vache, Chat, Chien]
Accès aux éléments individuels:
Vache, chat, chien,

2. Utilisation de la boucle forEach

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        // Creating an array list
        ArrayList<String> animals = new ArrayList<>();
        animals.add("Cow");
        animals.add("Cat");
        animals.add("Dog");
        System.out.println("ArrayList: " + animals);

        // Using forEach loop
        System.out.println("Accessing individual elements:  ");
        for(String animal : animals) {
            System.out.print(animal);
            System.out.print(", ");
        }
    }
}
 

Production

ArrayList: [Vache, Chat, Chien]
Accès aux éléments individuels:
Vache, chat, chien,

Dans les deux exemples, nous avons accédé à des éléments individuels d’une liste de tableaux à l’aide de boucles.


Obtenir la longueur de ArrayList

Pour obtenir la longueur de la liste des tableaux, nous utilisons le size() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals= new ArrayList<>();

        // Adding elements in the arrayList
        animals.add("Dog");
        animals.add("Horse");
        animals.add("Cat");
        System.out.println("ArrayList: " + animals);

        // getting the size of the arrayList
        System.out.println("Size: " + animals.size());
    }
}
 

Production

ArrayList: [Chien, Cheval, Chat]
Taille: 3

Trier les éléments d’une ArrayList

Pour trier les éléments d’une liste de tableaux, nous utilisons le sort() méthode de la Collections classe. Pour l’utiliser, nous devons importer le java.util.Collections paquet en premier.

Par défaut, le tri s’effectue par ordre alphabétique ou numérique par ordre croissant. Par exemple,

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

class Main {
    public static void main(String[] args){
        ArrayList<String> animals= new ArrayList<>();

        // Add elements in the array list
        animals.add("Horse");
        animals.add("Zebra");
        animals.add("Dog");
        animals.add("Cat");

        System.out.println("Unsorted ArrayList: " + animals);

        // Sort the array list
        Collections.sort(animals);
        System.out.println("Sorted ArrayList: " + animals);
    }
}
 

Production

ArrayList non trié: [Cheval, Zèbre, Chien, Chat]
ArrayList triée: [Chat, Chien, Cheval, Zèbre]

Pour en savoir plus sur le tri de la liste de tableaux, consultez la section Tri de Java ArrayList.


Java ArrayList à tableau

En Java, nous pouvons convertir des listes de tableaux en tableaux en utilisant le toArray() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals= new ArrayList<>();

        // Add elements in the array list
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayList: " + animals);

        // Create a new array of String type
        String[] arr = new String[animals.size()];

        // Convert ArrayList into an array
        animals.toArray(arr);
        System.out.print("Array: ");
        for(String item:arr) {
            System.out.print(item+", ");
        }
    }
}
 

Production

ArrayList: [Chien, Chat, Cheval]
Tableau: chien, chat, cheval,

Tableau Java vers ArrayList

Nous pouvons également convertir des tableaux en listes de tableaux. Pour cela, nous pouvons utiliser le asList() méthode de la Arrays classe.

Utiliser asList() , nous devons importer le java.util.Arrays paquet en premier. Par exemple,

 import java.util.ArrayList;
import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        // Create an array of String type
        String[] arr = {"Dog", "Cat", "Horse"};
        System.out.print("Array: ");

        // Print array
        for(String str: arr) {
            System.out.print(str);
            System.out.print(" ");
        }

        // Create an ArrayList from an array
        ArrayList<String> animals = new ArrayList<>(Arrays.asList(arr));
        System.out.println("\nArrayList: " + animals);
    }
}
 

Production

Tableau: chien, chat, cheval
ArrayList: [Chien, Chat, Cheval]

Dans le programme ci-dessus, nous avons d’abord créé un tableau arr du String type.

Nous avons ensuite converti le tableau en une liste de tableaux en utilisant le asList() méthode.


Java ArrayList en chaîne

Pour convertir une liste de tableaux en un String , nous pouvons utiliser le toString() méthode. Par exemple,

 import java.util.ArrayList;

class Main {
    public static void main(String[] args) {
        ArrayList<String> animals = new ArrayList<>();

        // Add elements in the ArrayList
        animals.add("Dog");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("ArrayList: " + animals);

        // Convert ArrayList into an String
        String str = animals.toString();
        System.out.println("String: " + str);
    }
}
 

Production

ArrayList: [Chien, Chat, Cheval]
Chaîne: [Chien, Chat, Cheval]

Remarque:  toString() convertit toute la liste des tableaux en un seul String .


Autres méthodes ArrayList

Méthodes Descriptions
 clone()  Crée une nouvelle liste de tableaux avec le même élément, la même taille et la même capacité.
 contains()  Recherche dans la liste des tableaux l’élément spécifié et renvoie un résultat booléen.
 ensureCapacity()  Spécifie l’élément total que la liste de tableaux peut contenir.
 isEmpty()  Vérifie si la liste des tableaux est vide.
 indexOf()  Recherche un élément spécifié dans une liste de tableaux et renvoie l’index de l’élément.
 trimToSize()