Java Liste des tableaux la classe utilise un dynamique tableau pour stocker les éléments. C'est comme un tableau, mais il y a pas de limite de taille . Nous pouvons ajouter ou supprimer des éléments à tout moment. Il est donc beaucoup plus flexible que le tableau traditionnel. On le retrouve dans le java.util emballer. C'est comme le Vector en C++.

L'ArrayList en Java peut également contenir des éléments en double. Il implémente l'interface List afin que nous puissions utiliser toutes les méthodes de l'interface List ici. ArrayList gère l'ordre d'insertion en interne.

Il hérite de la classe AbstractList et implémente Interface de liste .

Les points importants concernant la classe Java ArrayList sont :

• La classe Java ArrayList peut contenir des éléments en double.
• La classe Java ArrayList conserve l'ordre d'insertion.
• La classe Java ArrayList n'est pas synchronisé .
• Java ArrayList permet un accès aléatoire car le tableau fonctionne sur une base d'index.
• Dans ArrayList, la manipulation est un peu plus lente que dans LinkedList en Java car de nombreux déplacements doivent se produire si un élément est supprimé de la liste du tableau.
• Nous ne pouvons pas créer une liste de tableaux des types primitifs, tels que int, float, char, etc. Il est nécessaire d'utiliser la classe wrapper requise dans de tels cas. Par exemple:

 ArrayList al = ArrayList(); // does not work ArrayList al = new ArrayList(); // works fine 

• Java ArrayList est initialisé par la taille. La taille est dynamique dans la liste des tableaux, qui varie en fonction des éléments ajoutés ou supprimés de la liste.

Hiérarchie de la classe ArrayList

Comme le montre le diagramme ci-dessus, la classe Java ArrayList étend la classe AbstractList qui implémente l'interface List. L'interface List étend la Collection et Interfaces itérables dans l’ordre hiérarchique.

Déclaration de classe ArrayList

Voyons la déclaration de la classe java.util.ArrayList.

 public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, Serializable 

Constructeurs de ArrayList

Méthodes de ArrayList

Java Vs non générique. Collection générique

Le framework de collection Java n'était pas générique avant JDK 1.5. Depuis la 1.5, c'est générique.

La nouvelle collection générique Java vous permet de n'avoir qu'un seul type d'objet dans une collection. Il est désormais sécurisé, le transtypage n'est donc pas requis au moment de l'exécution.

Voyons l'ancien exemple non générique de création d'une collection Java.

 ArrayList list=new ArrayList();//creating old non-generic arraylist 

Voyons le nouvel exemple générique de création d'une collection Java.

 ArrayList list=new ArrayList();//creating new generic arraylist 

Dans une collection générique, nous spécifions le type entre accolades angulaires. Désormais, ArrayList est obligé de contenir le seul type d'objet spécifié. Si vous essayez d'ajouter un autre type d'objet, cela donne un erreur de compilation .

Pour plus d'informations sur les génériques Java, cliquez ici Tutoriel sur les génériques Java .

Exemple de liste de tableaux Java

Nom de fichier: ArrayListExample1.java

 import java.util.*; public class ArrayListExample1{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Printing the arraylist object System.out.println(list); } } 

Sortir:

[Mango, Apple, Banana, Grapes] 

Itération de ArrayList à l'aide d'Iterator

Voyons un exemple pour parcourir les éléments ArrayList à l'aide de l'interface Iterator.

Nom de fichier: ArrayListExample2.java

qu'est-ce que SVN Checkout

 import java.util.*; public class ArrayListExample2{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through Iterator Iterator itr=list.iterator();//getting the Iterator while(itr.hasNext()){//check if iterator has the elements System.out.println(itr.next());//printing the element and move to next } } } 

Sortir:

Mango Apple Banana Grapes 

Itération de ArrayList à l'aide de la boucle For-each

Voyons un exemple pour parcourir les éléments ArrayList en utilisant la boucle for-each

Nom de fichier: ArrayListExample3.java

 import java.util.*; public class ArrayListExample3{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add('Mango');//Adding object in arraylist list.add('Apple'); list.add('Banana'); list.add('Grapes'); //Traversing list through for-each loop for(String fruit:list) System.out.println(fruit); } } 

Sortir:

Mango Apple Banana Grapes 

Obtenir et définir ArrayList

Le méthode get() renvoie l'élément à l'index spécifié, alors que le méthode set() change l'élément.

Nom de fichier: ArrayListExample4.java

 import java.util.*; public class ArrayListExample4{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Mango'); al.add('Apple'); al.add('Banana'); al.add('Grapes'); //accessing the element System.out.println('Returning element: '+al.get(1));//it will return the 2nd element, because index starts from 0 //changing the element al.set(1,'Dates'); //Traversing list for(String fruit:al) System.out.println(fruit); } } 

Sortir:

Returning element: Apple Mango Dates Banana Grapes 

Comment trier la liste des tableaux

Le java.util le package fournit une classe utilitaire Collections , qui a la méthode statique sort(). En utilisant le Collections.sort() méthode, nous pouvons facilement trier la ArrayList.

Nom de fichier: SortArrayList.java

 import java.util.*; class SortArrayList{ public static void main(String args[]){ //Creating a list of fruits List list1=new ArrayList(); list1.add('Mango'); list1.add('Apple'); list1.add('Banana'); list1.add('Grapes'); //Sorting the list Collections.sort(list1); //Traversing list through the for-each loop for(String fruit:list1) System.out.println(fruit); System.out.println('Sorting numbers...'); //Creating a list of numbers List list2=new ArrayList(); list2.add(21); list2.add(11); list2.add(51); list2.add(1); //Sorting the list Collections.sort(list2); //Traversing list through the for-each loop for(Integer number:list2) System.out.println(number); } } 

Sortir:

Apple Banana Grapes Mango Sorting numbers... 1 11 21 51 

Façons d'itérer les éléments de la collection en Java

Il existe différentes manières de parcourir les éléments de la collection :

1. Par interface itérateur.
2. Par boucle for-each.
3. Par l'interface ListIterator.
4. Par boucle for.
5. Par la méthode forEach().
6. Par la méthode forEachRemaining().

Itérer la collection à travers les méthodes restantes

Voyons un exemple pour parcourir les éléments ArrayList par d'autres moyens

Nom de fichier: ArrayList4.java

 import java.util.*; class ArrayList4{ public static void main(String args[]){ ArrayList list=new ArrayList();//Creating arraylist list.add(&apos;Ravi&apos;);//Adding object in arraylist list.add(&apos;Vijay&apos;); list.add(&apos;Ravi&apos;); list.add(&apos;Ajay&apos;); System.out.println(&apos;Traversing list through List Iterator:&apos;); //Here, element iterates in reverse order ListIterator list1=list.listIterator(list.size()); while(list1.hasPrevious()) { String str=list1.previous(); System.out.println(str); } System.out.println(&apos;Traversing list through for loop:&apos;); for(int i=0;i<list.size();i++) { system.out.println(list.get(i)); } system.out.println('traversing list through foreach() method:'); the method is a new feature, introduced in java 8. list.foreach(a->{ //Here, we are using lambda expression System.out.println(a); }); System.out.println(&apos;Traversing list through forEachRemaining() method:&apos;); Iterator itr=list.iterator(); itr.forEachRemaining(a-&gt; //Here, we are using lambda expression { System.out.println(a); }); } } </list.size();i++)>

Sortir:

Traversing list through List Iterator: Ajay Ravi Vijay Ravi Traversing list through for loop: Ravi Vijay Ravi Ajay Traversing list through forEach() method: Ravi Vijay Ravi Ajay Traversing list through forEachRemaining() method: Ravi Vijay Ravi Ajay 

Objets de classe définis par l'utilisateur dans Java ArrayList

Voyons un exemple dans lequel nous stockons un objet de classe Student dans une liste de tableaux.

Nom de fichier: ArrayList5.java

 class Student{ int rollno; String name; int age; Student(int rollno,String name,int age){ this.rollno=rollno; this.name=name; this.age=age; } } 

 import java.util.*; class ArrayList5{ public static void main(String args[]){ //Creating user-defined class objects Student s1=new Student(101,'Sonoo',23); Student s2=new Student(102,'Ravi',21); Student s2=new Student(103,'Hanumat',25); //creating arraylist ArrayList al=new ArrayList(); al.add(s1);//adding Student class object al.add(s2); al.add(s3); //Getting Iterator Iterator itr=al.iterator(); //traversing elements of ArrayList object while(itr.hasNext()){ Student st=(Student)itr.next(); System.out.println(st.rollno+' '+st.name+' '+st.age); } } } 

Sortir:

 101 Sonoo 23 102 Ravi 21 103 Hanumat 25 

Exemple de sérialisation et de désérialisation Java ArrayList

Voyons un exemple pour sérialiser un objet ArrayList puis le désérialiser.

Nom de fichier: ArrayList6.java

 import java.io.*; import java.util.*; class ArrayList6 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); try { //Serialization FileOutputStream fos=new FileOutputStream('file'); ObjectOutputStream oos=new ObjectOutputStream(fos); oos.writeObject(al); fos.close(); oos.close(); //Deserialization FileInputStream fis=new FileInputStream('file'); ObjectInputStream ois=new ObjectInputStream(fis); ArrayList list=(ArrayList)ois.readObject(); System.out.println(list); }catch(Exception e) { System.out.println(e); } } } 

Sortir:

 [Ravi, Vijay, Ajay] 

Exemple Java ArrayList pour ajouter des éléments

Ici, nous voyons différentes manières d'ajouter un élément.

Nom de fichier: ArrayList7.java

 import java.util.*; class ArrayList7{ public static void main(String args[]){ ArrayList al=new ArrayList(); System.out.println('Initial list of elements: '+al); //Adding elements to the end of the list al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After invoking add(E e) method: '+al); //Adding an element at the specific position al.add(1, 'Gaurav'); System.out.println('After invoking add(int index, E element) method: '+al); ArrayList al2=new ArrayList(); al2.add('Sonoo'); al2.add('Hanumat'); //Adding second list elements to the first list al.addAll(al2); System.out.println('After invoking addAll(Collection c) method: '+al); ArrayList al3=new ArrayList(); al3.add('John'); al3.add('Rahul'); //Adding second list elements to the first list at specific position al.addAll(1, al3); System.out.println('After invoking addAll(int index, Collection c) method: '+al); } } 

Sortir:

Initial list of elements: [] After invoking add(E e) method: [Ravi, Vijay, Ajay] After invoking add(int index, E element) method: [Ravi, Gaurav, Vijay, Ajay] After invoking addAll(Collection c) method: [Ravi, Gaurav, Vijay, Ajay, Sonoo, Hanumat] After invoking addAll(int index, Collection c) method: [Ravi, John, Rahul, Gaurav, Vijay, Ajay, Sonoo, Hanumat] 

Exemple Java ArrayList pour supprimer des éléments

Ici, nous voyons différentes manières de supprimer un élément.

Nom de fichier: ArrayList8.java

 import java.util.*; class ArrayList8 { public static void main(String [] args) { ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); al.add('Anuj'); al.add('Gaurav'); System.out.println('An initial list of elements: '+al); //Removing specific element from arraylist al.remove('Vijay'); System.out.println('After invoking remove(object) method: '+al); //Removing element on the basis of specific position al.remove(0); System.out.println('After invoking remove(index) method: '+al); //Creating another arraylist ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); //Adding new elements to arraylist al.addAll(al2); System.out.println('Updated list : '+al); //Removing all the new elements from arraylist al.removeAll(al2); System.out.println('After invoking removeAll() method: '+al); //Removing elements on the basis of specified condition al.removeIf(str -> str.contains('Ajay')); //Here, we are using Lambda expression System.out.println('After invoking removeIf() method: '+al); //Removing all the elements available in the list al.clear(); System.out.println('After invoking clear() method: '+al); } } 

Sortir:

An initial list of elements: [Ravi, Vijay, Ajay, Anuj, Gaurav] After invoking remove(object) method: [Ravi, Ajay, Anuj, Gaurav] After invoking remove(index) method: [Ajay, Anuj, Gaurav] Updated list : [Ajay, Anuj, Gaurav, Ravi, Hanumat] After invoking removeAll() method: [Ajay, Anuj, Gaurav] After invoking removeIf() method: [Anuj, Gaurav] After invoking clear() method: [] 

Exemple Java ArrayList de la méthode retentionAll()

Nom de fichier: ArrayList9.java

 import java.util.*; class ArrayList9{ public static void main(String args[]){ ArrayList al=new ArrayList(); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); ArrayList al2=new ArrayList(); al2.add('Ravi'); al2.add('Hanumat'); al.retainAll(al2); System.out.println('iterating the elements after retaining the elements of al2'); Iterator itr=al.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

Sortir:

 iterating the elements after retaining the elements of al2 Ravi 

Exemple Java ArrayList de la méthode isEmpty()

Nom de fichier: ArrayList4.java

 import java.util.*; class ArrayList10{ public static void main(String [] args) { ArrayList al=new ArrayList(); System.out.println('Is ArrayList Empty: '+al.isEmpty()); al.add('Ravi'); al.add('Vijay'); al.add('Ajay'); System.out.println('After Insertion'); System.out.println('Is ArrayList Empty: '+al.isEmpty()); } } 

Sortir:

Is ArrayList Empty: true After Insertion Is ArrayList Empty: false 

Exemple Java ArrayList : Livre

Voyons un exemple de ArrayList dans lequel nous ajoutons des livres à la liste et imprimons tous les livres.

un formulaire complet

Nom de fichier: ArrayListExample20.java

 import java.util.*; class Book { int id; String name,author,publisher; int quantity; public Book(int id, String name, String author, String publisher, int quantity) { this.id = id; this.name = name; this.author = author; this.publisher = publisher; this.quantity = quantity; } } public class ArrayListExample20 { public static void main(String[] args) { //Creating list of Books List list=new ArrayList(); //Creating Books Book b1=new Book(101,'Let us C','Yashwant Kanetkar','BPB',8); Book b2=new Book(102,'Data Communications and Networking','Forouzan','Mc Graw Hill',4); Book b3=new Book(103,'Operating System','Galvin','Wiley',6); //Adding Books to list list.add(b1); list.add(b2); list.add(b3); //Traversing list for(Book b:list){ System.out.println(b.id+' '+b.name+' '+b.author+' '+b.publisher+' '+b.quantity); } } } 

Sortir:

101 Let us C Yashwant Kanetkar BPB 8 102 Data Communications and Networking Forouzan Mc Graw Hill 4 103 Operating System Galvin Wiley 6 

Taille et capacité d'une ArrayList

La taille et la capacité d’une liste de tableaux sont les deux termes que les débutants trouvent déroutants. Comprenons-le dans cette section à l'aide de quelques exemples. Considérez l'extrait de code suivant.

Nom de fichier: TailleCapacity.java

 import java.util.*; public class SizeCapacity { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(); System.out.println('The size of the array is: ' + al.size()); } } 

Sortir:

 The size of the array is: 0 

Explication: Le résultat est logique car nous n’avons rien fait avec la liste des tableaux. Observez maintenant le programme suivant.

Nom de fichier: TailleCapacité1.java

 import java.util.*; public class SizeCapacity1 { public static void main(String[] args) throws Exception { ArrayList al = new ArrayList(10); System.out.println('The size of the array is: ' + al.size()); } } 

Sortir:

 The size of the array is: 0 

Explication: Nous voyons que la taille est toujours 0, et la raison derrière cela est que le chiffre 10 représente la capacité et non la taille. En fait, la taille représente le nombre total d’éléments présents dans le tableau. Comme nous n’avons ajouté aucun élément, la taille de la liste des tableaux est donc nulle dans les deux programmes.

La capacité représente le nombre total d'éléments que la liste de tableaux peut contenir. Par conséquent, la capacité d’une liste de tableaux est toujours supérieure ou égale à la taille de la liste de tableaux. Lorsque nous ajoutons un élément à la liste de tableaux, il vérifie si la taille de la liste de tableaux est devenue égale à la capacité ou non. Si oui, alors la capacité de la liste de tableaux augmente. Ainsi, dans l'exemple ci-dessus, la capacité sera de 10 jusqu'à ce que 10 éléments soient ajoutés à la liste. Quand on ajoute le 11^èmeélément, la capacité augmente. Notez que dans les deux exemples, la capacité de la liste des tableaux est de 10. Dans le premier cas, la capacité est de 10 car la capacité par défaut de la liste des tableaux est de 10. Dans le second cas, nous avons explicitement mentionné que la capacité du tableau la liste est 10.

Remarque : Il n'existe aucune méthode standard pour indiquer comment la capacité augmente dans la liste des baies. En fait, la façon dont la capacité augmente varie d'une version de GDK à l'autre. Par conséquent, il est nécessaire de vérifier la manière dont le code d’augmentation de capacité est implémenté dans le GDK. Il n'existe aucune méthode prédéfinie dans la classe ArrayList qui renvoie la capacité de la liste de tableaux. Par conséquent, pour une meilleure compréhension, utilisez la méthode capacité() de la classe Vector. La logique de taille et de capacité est la même dans la classe ArrayList et la classe Vector.

Rubriques connexes

Comment trier ArrayList en Java

Différence entre un tableau et une liste de tableaux

Quand utiliser ArrayList et LinkedList en Java

Différence entre ArrayList et LinkedList

Différence entre ArrayList et Vector

Comment comparer deux ArrayList en Java

Comment inverser ArrayList en Java

Quand utiliser ArrayList et LinkedList en Java

Comment rendre ArrayList en lecture seule

Différence entre la longueur du tableau et la taille () de ArrayList en Java

Comment synchroniser ArrayList en Java

Comment convertir ArrayList en Array et Array en ArrayList en Java

Tableau vs ArrayList en Java

quels sont les mois du premier trimestre

Comment trier Java ArrayList par ordre décroissant

Comment supprimer les doublons d'ArrayList en Java