ArrayList Java

Dans ce tutoriel, nous allons apprendre la classe Java ArrayList. Nous allons apprendre différentes opérations et méthodes de ArrayList à l'aide d'exemples.

La classe ArrayList est une implémentation de l'interface List, qui nous permet de créer des arrays ajustables en taille.

Java Array et ArrayList

En Java, nous devons d'abord déclarer la taille de l'array, puis nous pouvons l'utiliser. Une fois la taille de l'array déclarée, il est difficile de la modifier.

Pour résoudre ce problème, nous pouvons utiliser la classe ArrayList. La classe ArrayList existant dans le paquet java.util nous permet de créer des arrays ajustables en taille.

Différent de l'array, lorsque nous ajoutons ou supprimons des éléments dans une liste d'arrays (un objet de la classe ArrayList), la liste d'arrays peut automatiquement ajuster sa capacité. Par conséquent, la liste d'arrays est également appelée array dynamique.

Créer ArrayList

C'est la manière dont nous pouvons créer une liste d'arrays en Java :

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

Ici, Type indique le type de la liste d'arrays. Par exemple,

//Créer une ArrayList de type entier
ArrayList<Integer> arrayList = new ArrayList<>();
//Créer une ArrayList de type chaîne de caractères
ArrayList<String> arrayList = new ArrayList<>();

Dans le programme ci-dessus, nous avons utilisé Integer et String. Ici, Integer est la classe d'emballage correspondante au type int.

Note:Nous ne pouvons pas créer de liste d'arrays pour des types de données primaires (comme int, float, char, etc.). Au lieu de cela, nous devons utiliser leurs classes d'emballage correspondantes.

Pour les chaînes de caractères, String est une classe, sans classe d'emballage. Par conséquent, nous l'utilisons telle quelle.

Nous pouvons également utiliser l'interface List pour créer une ArrayList. Cela est dû au fait que la classe ArrayList implémente l'interface List.

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

Méthodes de ArrayList

ArrayList fournit diverses méthodes nous permettant d'exécuter des opérations sur les listes d'arrays.

Ajouter un élément à ArrayList

1.Utiliser la méthode add()

Pour ajouter un seul élément à une liste d'arrays, nous utilisons la méthode add(). Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter un élément
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　}
}

Output result

ArrayList: [Dog, Cat, Horse]

2.Utiliser le numéro d'index

Nous pouvons également utiliser un index pour ajouter des éléments à une liste d'arrays. Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter un élément
　　　　　　　　animals.add(0,"Chien");
　　　　　　　　animals.add(1,"Chat");
　　　　　　　　animals.add(2,"Cheval");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　}
}

Output result

ArrayList: [Dog, Cat, Horse]

3.Ajouter les éléments d'une liste d'arrays à une autre liste d'arrays

Pour ajouter tous les éléments d'une liste d'arrays à une nouvelle liste d'arrays, utilisez la méthode addAll(). Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　ArrayList<String> mammals = new ArrayList<>();
　　　　　　　　mammals.add("Chien");
　　　　　　　　mammals.add("Chat");
　　　　　　　　mammals.add("Cheval");
　　　　　　　　System.out.println("Mammifères: "
)　+　mammals);
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　animals.add("Crocodile");
　　　　　　　　//　Ajouter tous les éléments de mammals à animals
　　　　　　　　animals.addAll(mammals);
　　　　　　　　System.out.println("Animaux: "
)　+　animals);
　　　　}
}

Output result

Mammifères:　[Dog,　Cat,　Horse]
Animaux:　[Crocodile,　Dog,　Cat,　Horse]

Initialiser ArrayList en utilisant asList()

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

Pour utiliser la méthode asList(), nous devons d'abord importer le paquet java.util.Arrays.

Par exemple,

import java.util.ArrayList;
import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer une liste d'arrays
　　　　　　　　ArrayList<String>　animals　=　new　ArrayList<>(Arrays.asList("Cat",　"Cow",　"Dog"));
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Accéder à un élément de la liste de tableaux
　　　　　　　　String　element　=　animals.get(1);
　　　　　　　　System.out.println("Accéder à l'élément:　"　+　element);
　　　　}
}

Output result

ArrayList:　[Cat,　Cow,　Dog]
Accéder à l'élément:　Cow

Dans l'exemple ci-dessus, veuillez noter les expressions suivantes :

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

Ici, nous créons d'abord3Un tableau d'éléments : "Cat", "Cow", et "Dog". Puis, la méthode asList() est utilisée pour convertir le tableau en liste de tableaux.

Accéder aux éléments de l'ArrayList

1.Utiliser la méthode get()

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

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Cheval");
　　　　　　　　animals.add("Chat");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Obtenir un élément de la liste de tableaux
　　　　　　　　String　str　=　animals.get(0);
　　　　　　　　System.out.print("L'élément à l'indice 0:　"　+　str);
　　　　}
}

Output result

ArrayList: [Chien, Cheval, Chat]
L'élément à l'indice 0:　Dog

2.Utiliser la méthode iterator()

Pour accéder aux éléments de la liste de tableaux en ordre, nous utilisons la méthode iterator(). Nous devons importer le paquet java.util.Iterator 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<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　animals.add("Zèbre");
　　　　　　　　//Créer un objet Iterator
　　　　　　　　Iterator<String>　iterate　=　animals.iterator();
　　　　　　　　System.out.print("ArrayList:　");
　　　　　　　　//Utiliser la méthode Iterator pour accéder aux éléments
　　　　　　　　while(iterate.hasNext()){
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output result

ArrayList: Dog, Cat, Horse, Zebra,

Remarques:

• hasNext() - si la liste d'arrays a un élément suivant, retourne true.

• next()　 -　 Retourner l'élément suivant de la liste d'arrays

Modifier l'élément ArrayList

Pour modifier un élément de la liste d'arrays, nous pouvons utiliser la méthode set(). Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Modifier l'élément de la liste d'arrays
　　　　　　　　animals.set(2, "Zebra");
　　　　　　　　System.out.println("ArrayList modifiée: ");　+　animals);
　　　　}
}

Output result

ArrayList: [Dog, Cat, Horse]
ArrayList modifiée: [Dog, Cat, Zebra]

Supprimer l'élément ArrayList

1.Utilisation de la méthode remove()

Pour supprimer un élément d'une liste d'arrays, nous pouvons utiliser la méthode remove(). Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList initiale: ");　+　animals);
　　　　　　　　//de l'index2enlever l'élément
　　　　　　　　String str = animals.remove(2);
　　　　　　　　System.out.println("ArrayList finale: ");　+　animals);
　　　　　　　　System.out.println("Supprimer l'élément: ");　+　str);
　　　　}
}

Output result

ArrayList initiale: [Dog, Cat, Horse]
ArrayList final: [Dog, Cat]
Supprimer l'élément: Horse

2.Utilisation de la méthode removeAll()

Pour supprimer tous les éléments d'une liste d'arrays, nous utilisons la méthode removeAll(). Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　Ajouter des éléments à l'ArrayList
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList initiale: ");　+　animals);
　　　　　　　　//　Supprimer tous les éléments
　　　　　　　　animals.removeAll(animals);
　　　　　　　　System.out.println("ArrayList finale: ");　+　animals);
　　　　}
}

Output result

ArrayList initiale: [Dog, Cat, Horse]
ArrayList final: []

3.Utilisation de la méthode clear()

Nous pouvons également utiliser la méthode clear() pour supprimer tous les éléments d'une liste d'arrays. Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList initiale: ");　+　animals);
　　　　　　　　//Supprimer tous les éléments
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("ArrayList finale: ");　+　animals);
　　　　}
}

Output result

ArrayList initiale: [Dog, Cat, Horse]
ArrayList final: []

Note:La méthode clear() est plus efficace que la méthode removeAll().

Parcourir ArrayList

1.Utilisation de la boucle for

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer une liste d'arrays
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　animals.add("Vache");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Chien");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Utilisation de la boucle for
　　　　　　　　System.out.println("Accès à tous les éléments: ");
　　　　　　　　for(int i = 0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output result

ArrayList: [Vache, Chat, Chien]
Accéder à tous les éléments:
Vache, Chat, Chien,

2Utilisation de la boucle forEach

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//　Créer une liste d'arrays
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　animals.add("Vache");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Chien");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Utiliser la boucle forEach
　　　　　　　　System.out.println("Accéder à tous les éléments: ");
　　　　　　　　for(String animal : animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output result

ArrayList: [Vache, Chat, Chien]
Accéder à tous les éléments:
Vache, Chat, Chien,

Dans les deux exemples, nous avons tous deux utilisé une boucle pour accéder aux éléments de la liste d'arrays.

Obtenir la longueur d'ArrayList

Pour obtenir la longueur d'une liste d'arrays, nous utilisons la méthode size(). Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　Ajouter des éléments dans arrayList
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Cheval");
　　　　　　　　animals.add("Chat");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Obtenir la taille de arrayList
　　　　　　　　System.out.println("La taille de arrayList: ",　+　animals.size());
　　　　}
}

Output result

ArrayList: [Chien, Cheval, Chat]
La taille de arrayList:　3

Trier les éléments d'ArrayList

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

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

import java.util.ArrayList;
import java.util.Collections;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Cheval");
　　　　　　　　animals.add("Zèbre");
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　System.out.println("ArrayList non triée: ",　+　animals);
　　　　　　　　//Trier une liste d'arrays
　　　　　　　　Collections.sort(animals);
　　　　　　　　System.out.println("ArrayList triée: ",　+　animals);
　　　　}
}

Output result

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

Pour plus d'informations sur le tri des listes d'arrays, visitez Java ArrayList sort.

Conversion d'ArrayList Java en tableau

En Java, nous pouvons utiliser la méthode toArray() pour convertir une liste d'arrays en tableau. Par exemple,

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments dans une liste d'arrays
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Créer un nouveau tableau de type String
　　　　　　　　String[] arr = new String[animals.size()];
　　　　　　　　//Convertir ArrayList en tableau
　　　　　　　　animals.toArray(arr);
　　　　　　　　System.out.print("Tableau: ");
　　　　　　　　for(String item:arr) {
　　　　　　　　　　　　System.out.print(item+", ");
　　　　　　　　}
　　　　}
}

Output result

ArrayList: [Dog, Cat, Horse]
Tableau: Chien, Chat, Cheval,

Conversion de tableau Java en ArrayList

Nous pouvons également convertir un tableau en liste d'arrays. À cette fin, nous pouvons utiliser la méthode asList() de la classe Arrays.

Pour utiliser asList(), nous devons d'abord importer le paquet java.util.Arrays. Par exemple,

import java.util.ArrayList;
import java.util.Arrays;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Créer un tableau de type String
　　　　　　　　String[] arr = {"Chien", "Chat", "Cheval"};
　　　　　　　　System.out.print("Tableau: ");
　　　　　　　　//Imprimer le tableau
　　　　　　　　for(String str: arr) {
　　　　　　　　　　　　System.out.print(str);
　　　　　　　　　　　　System.out.print(" ");
　　　　　　　　}
　　　　　　　　//Créer ArrayList à partir de tableau
　　　　　　　　ArrayList<String> animals = new ArrayList<>(Arrays.asList(arr));
　　　　　　　　System.out.println("\nArrayList: "　+　animals);
　　　　}
}

Output result

Tableau: Chien, Chat, Cheval
ArrayList: [Dog, Cat, Horse]

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

Ensuite, nous utilisons la méthode asList() pour convertir un tableau en liste d'arrays.

Conversion de ArrayList Java en chaîne

Pour convertir une liste d'arrays en chaîne de caractères, vous pouvez utiliser la méthode toString(). Par exemple

import java.util.ArrayList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Ajouter des éléments à l'ArrayList
　　　　　　　　animals.add("Chien");
　　　　　　　　animals.add("Chat");
　　　　　　　　animals.add("Cheval");
　　　　　　　　System.out.println("ArrayList: "　+　animals);
　　　　　　　　//Convert ArrayList to a string
　　　　　　　　String str = animals.toString();
　　　　　　　　System.out.println("String: "　+　str);
　　　　}
}

Output result

ArrayList: [Dog, Cat, Horse]
String: [Dog, Cat, Horse]

Note: toString() converts the entire array list to a single String.

Other ArrayList methods