Méthodes ArrayList en Java

arraylist methods java tutorial with example programs

Essayez Notre Instrument Pour Éliminer Les Problèmes

Sélectionnez Le Système D'Exploitation Choisissez Un Programme De Projection (Éventuellement)

Décrivez Votre Problème

Dans ce didacticiel, nous discuterons des méthodes Java ArrayList telles que add, addAll, remove, removeAll, size, contains, retentionAll, Sort, Reverse, etc. avec des exemples:

Dans le didacticiel précédent, nous avons exploré la structure de données ArrayList et la classe ArrayList fournie pour cette structure / collection de données en Java. Nous avons appris la création, l'initialisation, etc. des objets ArrayList.

Outre ces fonctionnalités qui nous aident à définir ArrayList, la classe ArrayList en Java fournit également une API de fonction à part entière composée de méthodes utilisées pour manipuler les objets ArrayList.

=> Consultez TOUS les didacticiels Java ici.

Ces méthodes nous permettent d'ajouter, de supprimer, de rechercher des éléments dans ArrayList ainsi que de récupérer la longueur / taille des éléments ArrayList, etc.

Java ArrayList_Methods

Dans ce didacticiel, nous aborderons ces méthodes en détail avec des exemples de programmation simples.

Ce que vous apprendrez:

Le tableau suivant répertorie toutes les méthodes fournies par la classe ArrayList.

Méthode	Prototype de méthode	Description de la méthode
Contient	boolean contient (Object o)	Vérifie si la liste contient l’élément «o» donné. Renvoie true si l'élément est présent.
Ajouter	booléen ajouter (E e)	Ajoute l'élément e donné à la fin de la liste.
Ajouter	void add (index int, élément E)	Ajoute un élément donné «élément» à la position spécifiée «index».
Tout ajouter	booléen addAll (Collection c)	Ajoute tous les éléments de la collection donnée c à la fin de la liste.
Tout ajouter	booléen addAll (index int, Collection c)	Ajoute tous les éléments de la collection donnée c à la position spécifiée par l ’« index »dans la liste.
Clair	vide clair ()	Efface la liste en supprimant tous les éléments de la liste.
Cloner	Clone d'objet ()	Crée une copie superficielle de la ArrayList donnée.
assurerCapacité	void ensureCapacity (int minCapacity)	Augmente la capacité de la ArrayList pour s'assurer qu'elle a la capacité minCapacity.
Obtenir	E get (index int)	Renvoie l’élément de la liste présent à la position spécifiée par ‘index’.
Indice de	int indexOf (objet o)	Renvoie l'index de la première occurrence de l'élément o dans la liste. -1 si l'élément o n'est pas présent dans la liste.
est vide	booléen isEmpty ()	Vérifie si la liste donnée est vide.
Itérateur	Itérateur itérateur ()	Renvoie un itérateur pour parcourir les éléments de la liste dans la séquence appropriée.
lastIndexOf	int lastIndexOf (objet o)	Renvoie l'index de la dernière occurrence de l'élément spécifié o dans la liste. -1 si l'élément n'est pas présent dans la liste.
listIterator	ListIterator listIterator ()	Renvoie un itérateur de liste pour parcourir les éléments de la liste donnée.
listIterator	ListIterator listIterator (index int)	Renvoie l'itérateur de liste à partir de la position spécifiée «index» pour parcourir les éléments de la liste donnée.
supprimer	E supprimer (index int)	Supprime l’élément à l’index dans ArrayList.
supprimer	boolean remove (objet o)	Supprime la première occurrence de l'élément o de la liste.
Enlever tout	booléen removeAll (Collection c)	Supprime tous les éléments de la liste qui correspondent aux éléments d'une collection donnée c.
removeRange	protected void removeRange (int fromIndex, int toIndex)	Supprime les éléments spécifiés dans la plage donnée, fromIndex (inclus) à toIndex (exclusif) de la liste.
retenirTout	booléen retentionAll (Collection c)	Conserve les éléments de la liste qui correspondent aux éléments de la collection donnée c.
ensemble	Ensemble E (index int, élément E)	Définit la valeur de l'élément à un «index» donné sur la nouvelle valeur donnée par «élément».
Taille	taille int ()	Renvoie le nombre total d'éléments ou la longueur de la liste.
sous-liste	Liste des sous-listes (int fromIndex, int toIndex)	Renvoie une sous-liste entre une plage donnée, fromIndex à toIndex pour la liste donnée.
toArray	Object () toArray ()	Convertit la liste donnée en un tableau.
toArray	T () toArray (T () a)	Convertit la liste donnée en un tableau du type donné par a.
trimToSize	void trimToSize ()	Ajuste la capacité de ArrayList à la taille ou au nombre d'éléments présents dans la liste.

Ensuite, nous discuterons en détail de chacune de ces méthodes de l'API de la fonction ArrayList et présenterons des exemples de programmation. Après avoir discuté de toutes les méthodes répertoriées ci-dessus, nous aborderons également certaines opérations spécifiques effectuées à l'aide de ArrayLists qui ne font pas partie de l'API de la fonction ArrayList.

ArrayList ajouter

Prototype: booléen ajouter (E e)
Paramètres: e => Élément à ajouter à ArrayList.
Valeur de retour: true => Élément ajouté avec succès.
Description: Ajoute l'élément e donné à la fin de la liste.

II.

Prototype: void add (index int, élément E)

Paramètres:

index => Position à laquelle l'élément doit être ajouté.
Element => Élément à ajouter à la ArrayList.

Valeur de retour: annuler

Description: Ajoute un élément donné «élément» à la position spécifiée «index» en déplaçant l’élément à cette position et les éléments suivants vers la droite.

Des exceptions: IndexOutOfBoundsException => Si l'index spécifié est hors de la plage.

ArrayList addAll

Prototype: booléen addAll (Collection c)
Paramètres: c => Collection dont les éléments doivent être ajoutés à ArrayList.
Valeur de retour: true => Si l'opération a modifié ArrayList.

Description: Ajoute tous les éléments de la collection donnée c à la fin de la liste. Le résultat de l'opération n'est pas défini si la collection est modifiée lorsque l'opération est en cours.

Des exceptions: NullPointerException => Si la collection donnée c est nulle.

Prototype: booléen addAll (index int, Collection c)
Paramètres: index => Position à laquelle les éléments de la collection donnée doivent être ajoutés.
Valeur de retour: true => Si la liste a changé suite à l'opération.

Description: Ajoute tous les éléments de la collection donnée c à la position spécifiée par l ’« index »dans la liste. L'élément à l'index spécifié et les éléments suivants sont décalés vers la droite. Le résultat de l'opération n'est pas défini si la collection ajoutée est modifiée lorsque l'opération est en cours.

Des exceptions: IndexOutOfBoundsException: si l'index où la collection doit être ajoutée est hors limites
NullPointerException: si la collection donnée c est nulle.

Le programme Java suivant illustre l'utilisation des méthodes add et addAll.

import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print the list System.out.println('Initial ArrayList:' + city_List); //add an element at index 1 using add method overload city_List.add(1, 'NYC'); //print the list System.out.println('
rrayList after adding element at index 1:' + city_List); //define a second list ArrayList more_Cities = new ArrayList(Arrays.asList('Pune', 'Hyderabad')); //use addAll method to add the list to ArrayList at index 4 city_List.addAll(4,more_Cities); //print the list System.out.println('
ArrayList after adding list at index 4:' + city_List); } }

Production:

ArrayList initiale: (Delhi, Mumbai, Chennai, Kolkata)
rrayList après l'ajout d'un élément à l'index 1: (Delhi, NYC, Mumbai, Chennai, Kolkata)
ArrayList après avoir ajouté la liste à l'index 4: (Delhi, NYC, Mumbai, Chennai, Pune, Hyderabad, Kolkata)

Sortie de Java ArrayList addAll

Le programme ci-dessus utilise les deux versions de la méthode add pour ajouter des éléments à la liste. Il ajoute également une collection à la liste à l'index spécifié. Notez le déplacement des éléments vers la droite de ArrayList comme évident à partir de la sortie du programme.

ArrayList Ajouter au premier plan

Comme déjà mentionné, la première version de la méthode add ajoute les éléments à la fin de la liste. Si vous souhaitez ajouter les éléments au début de la ArrayList, vous devez utiliser la deuxième version de la méthode add. Cette méthode add prend un index comme paramètre. Cet index est la position à laquelle l'élément doit être ajouté.

Ainsi, pour ajouter l'élément au début de la liste, vous devez spécifier l'index comme 0 qui est le début de la liste.

Le programme suivant ajoute un élément au début de ArrayList.

import java.util.ArrayList; public class Main { public static void main(String() args) { //define new ArrayList and initialize it ArrayList numList = new ArrayList(); numList.add(5); numList.add(7); numList.add(9); //print the ArrayList System.out.println('Initial ArrayList:'); System.out.println(numList); //use add method with index=0 to add elements to the beginning of the list numList.add(0, 3); numList.add(0, 1); System.out.println('ArrayList after adding elements at the beginning:'); //print ArrayList System.out.println(numList); } }

Production:

ArrayList initiale:
(5, 7, 9)
ArrayList après avoir ajouté des éléments au début:
(1, 3, 5, 7, 9)

Sortie - ArrayList ajouté à l

ArrayList supprimer

JE.

Prototype: E supprimer (index int)
Paramètres: index => Position à laquelle l'élément doit être supprimé de ArrayList.
Valeur de retour: E => Élément supprimé
Description: Supprime l’élément à l’index dans ArrayList et déplace les éléments suivants vers la gauche.
Des exceptions: IndexOutOfBoundsException => L'index spécifié est hors de portée.

II.

Prototype: boolean remove (objet o)
Paramètres: o => Élément à supprimer de ArrayList.
Valeur de retour: true => Si l'élément est présent dans la liste.

Description: Supprime la première occurrence de l'élément o de la liste. Si l'élément n'est pas présent dans la liste, alors il n'y a aucun effet de cette opération. Une fois l'élément supprimé, les éléments suivants sont décalés vers la gauche.

ArrayList removeAll

Prototype: booléen removeAll (Collection c)
Paramètres: c => Collection dont les éléments correspondent à ceux de ArrayList et doivent être supprimés.
Valeur de retour: true => Si la ArrayList est modifiée par l'opération.

Description: Supprime tous les éléments de la liste qui correspondent aux éléments de la collection donnée c. Par conséquent, les éléments restants sont déplacés vers la gauche de la liste.

Des exceptions: ClassCastException => La classe n'est pas la même que celle de la collection spécifiée, ce qui implique que la classe est incompatible.
NullPointerException => Si la collection donnée c est nulle; ou si c a un élément nul et qu'il n'est pas autorisé par la collection.

ArrayList removeRange

Prototype: protected void removeRange (int fromIndex, int toIndex)
Paramètres: fromIndex => Index de l'élément de départ de la plage à supprimer.
toIndex => Index de l'élément après le dernier élément de la plage à supprimer.
Valeur de retour: annuler
Description: Supprime les éléments spécifiés dans la plage donnée, fromIndex (inclus) à toIndex (exclusif) de la liste. Cette opération raccourcit la longueur de la liste de (toIndex-fromIndex). Cette opération n'a aucun effet dans le cas où fromIndex = toIndex.
Des exceptions: IndexOutOfBoundsException => Si l'un des indices (fromIndex ou toIndex) est hors limites.

Implémentons un programme Java pour illustrer certaines de ces méthodes de suppression dont nous avons parlé ci-dessus.

import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(Arrays.asList('Delhi','Mumbai','Chennai', 'Kolkata', 'Pune', 'Hyderabad')); //print the list System.out.println('Initial ArrayList:' + city_List); //remove element at index 2 city_List.remove(2); //print the list System.out.println('
ArrayList after removing element at index 2:' + city_List); //remove the element 'Kolkata' city_List.remove('Kolkata'); //print the list System.out.println('
ArrayList after removing element -> Kolkata:' + city_List); //create new list ArrayList newCities=new ArrayList(Arrays.asList('Delhi','Hyderabad')); //call removeAll to remove elements contained in newCities list. city_List.removeAll(newCities); //print the list System.out.println('
ArrayList after call to removeAll:' + city_List); } }

Production:

ArrayList initiale: (Delhi, Mumbai, Chennai, Kolkata, Pune, Hyderabad
ArrayList après suppression de l'élément à l'index 2: (Delhi, Mumbai, Kolkata, Pune, Hyderabad)
ArrayList après avoir supprimé l'élément -> Kolkata: (Delhi, Mumbai, Pune, Hyderabad)
ArrayList après appel à removeAll: (Mumbai, Pune)

Sortie - ArrayList removeAll range

Taille de ArrayList (longueur)

Prototype: taille int ()
Paramètres: NÉANT
Valeur de retour: int => Nombre d'éléments dans ArrayList.
Description: Renvoie le nombre total d'éléments ou la longueur de ArrayList.

AssurerCapacité

Prototype: void ensureCapacity (int minCapacity)
Paramètres: minCapacity => La capacité minimale souhaitée pour la ArrayList.
Valeur de retour: annuler
Description: Augmente la capacité de ArrayList pour garantir qu'il a la capacité minCapacity.

trimToSize

Prototype: void trimToSize ()
Paramètres: NÉANT
Valeur de retour: annuler
Description: Ajuste la capacité de ArrayList à la taille ou au nombre d'éléments présents dans la liste.

L'exemple de programmation ci-dessous illustre les méthodes size (), ensureCapacity () et trimToSize ().

import java.util.ArrayList; public class Main { public static void main(String () args) { //Create and initialize Arraylist ArrayList evenList=new ArrayList(5); System.out.println('Initial size: '+evenList.size()); evenList.add(2); evenList.add(4); evenList.add(6); evenList.add(8); evenList.add(10); //print the list and size System.out.println('Original List: ' + evenList); System.out.println('ArrayList Size after add operation: '+evenList.size()); //call ensureCapacity () with minimum capacity =10 evenList.ensureCapacity(10); //add two more elements evenList.add(12); evenList.add(14); //print the size again System.out.println('ArrayList Size after ensureCapacity() call and add operation: '+evenList.size()); //call trimToSize() evenList.trimToSize(); //print the size and the ArrayList System.out.println('ArrayList Size after trimToSize() operation: '+evenList.size()); System.out.println('ArrayList final: '); for(int num: evenList){ System.out.print(num + ' '); } } }

Production:

Taille initiale: 0
Liste d'origine: (2, 4, 6, 8, 10)
Taille de ArrayList après l'opération d'ajout: 5
ArrayList Taille après appel à ensureCapacity () et opération d'ajout: 7
ArrayList Taille après l'opération trimToSize (): 7
ArrayList final:
2 4 6 8 10 12 14

Sortie - Taille de ArrayList (longueur)

ArrayList contient

Prototype: boolean contient (Object o)
Paramètres: o => Élément à vérifier s'il est présent dans ArrayList.
Valeur de retour: true => Si le ArrayList contient l'élément o.
Description: Vérifie si la liste contient l’élément «o» donné. Renvoie true si l'élément est présent.

Nous utilisons la méthode «contient» dans le programme suivant.

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call contains method to check if different strings are present in ArrayList System.out.println('ArrayList contains ('Red Green'): ' +colorsList.contains('Red Green')); System.out.println('ArrayList contains ('Blue'): ' +colorsList.contains('Blue')); System.out.println('ArrayList contains ('Yellow'): ' +colorsList.contains('Yellow')); System.out.println('ArrayList contains ('White'): ' +colorsList.contains('White')); } }

Production:

ArrayList contient ('Rouge Vert'): faux
ArrayList contient ('Bleu'): vrai
ArrayList contient ('Jaune'): faux
ArrayList contient ('Blanc'): vrai

Sortie - ArrayList contient

Comme indiqué dans la sortie ci-dessus, la méthode ‘contains’ vérifie si l’argument fourni est présent dans ArrayList et renvoie vrai ou faux.

ArrayList obtenir

Prototype: E get (index int)
Paramètres: index => Index à quel élément doit être récupéré dans ArrayList.
Valeur de retour: E => Valeur de l'élément à l'index donné dans ArrayList.
Description: Renvoie l’élément de la liste présent à la position spécifiée par ‘index’.
Des exceptions: IndexOutOfBoundsException => Si l'index est hors limites.

Ensemble ArrayList (élément de remplacement)

Prototype: Ensemble E (index int, élément E)
Paramètres: index => Index auquel l'élément doit être remplacé.
Element => Nouvel élément à définir à l'index spécifié.
Valeur de retour: E => Élément remplacé par l'opération set.
Description: Définit la valeur de l’élément à l’index donné sur la nouvelle valeur donnée par l’élément.
Des exceptions: IndexOutOfBoundsException => Si l'index est hors limites

Le programme Java ci-dessous utilise les méthodes get () et set () pour récupérer et remplacer les valeurs dans ArrayList.

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //call get () method to retrieve value at index 2 System.out.println('Entry at index 2 before call to set: ' + colorsList.get(2)); //replace the value at index 2 with new value colorsList.set(2,'Yellow'); //print the value at index 2 again System.out.println('Entry at index 2 after call to set: ' + colorsList.get(2)); } }

Production:

Entrée à l'index 2 avant l'appel à régler: Bleu
Entrée à l'index 2 après appel à régler: jaune

Production

ArrayList clair

Prototype: vide clair ()
Paramètres: NÉANT
Valeur de retour: annuler
Description: Efface la liste en supprimant tous les éléments de la liste.

ArrayList est vide

Prototype: booléen isEmpty ()
Paramètres: NÉANT
Valeur de retour: true => si la liste est vide
Description: Vérifie si la liste donnée est vide.

Les fonctions Clear () et isEmpty () sont illustrées ci-dessous.

comment lire un fichier swf

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize colorsList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('White'); //print the ArrayList System.out.println('The ArrayList: ' + colorsList); //call clear() nethod on ArrayList colorsList.clear(); //check if ArrayList is empty using isEmpty() method System.out.println('Is ArrayList empty after clear ()? :' + colorsList.isEmpty()); } }

Production:

The ArrayList: (Rouge, Vert, Bleu, Blanc)
ArrayList est-il vide après clear ()? :vrai

Sortie - isEmpty ArrayList

ArrayList indexOf

Prototype: int indexOf (objet o)
Paramètres: o => Élément dont l'index se trouve dans ArrayList.
Valeur de retour: int => Index de la première occurrence de l'élément dans la liste.
Description: Renvoie l'index de la première occurrence de l'élément o dans la liste. -1 si l'élément o n'est pas présent dans la liste.

ArrayList lastIndexOf

Prototype: int lastIndexOf (objet o)
Paramètres: o => L'élément à rechercher.
Valeur de retour: int => Index de la dernière occurrence de l'élément dans la liste.
Description: Renvoie l'index de la dernière occurrence de l'élément spécifié o dans la liste. -1 si l'élément n'est pas présent dans la liste.

Le programme Java ci-dessous illustre les méthodes indexOf et lastIndexOf de ArrayList.

import java.util.ArrayList; public class Main { public static void main(String() args) { //create and initialize intList ArrayList intList = new ArrayList(); intList.add(1); intList.add(1); intList.add(2); intList.add(3); intList.add(5); intList.add(3); intList.add(2); intList.add(1); intList.add(1); //print the ArrayList System.out.println('The ArrayList: ' + intList); //call indexOf() and lastIndexOf() methods to check the indices of specified elements System.out.println('indexOf(1) : ' + intList.indexOf(1)); System.out.println('lastIndexOf(1) : ' + intList.lastIndexOf(1)); System.out.println('indexOf(2) : ' + intList.indexOf(2)); System.out.println('lastIndexOf(2) : ' + intList.lastIndexOf(2)); System.out.println('indexOf(3) : ' + intList.indexOf(3)); System.out.println('lastIndexOf(3) : ' + intList.lastIndexOf(3)); System.out.println('indexOf(5) : ' + intList.indexOf(5)); System.out.println('lastIndexOf(5) : ' + intList.lastIndexOf(5)); } }

Production:

ArrayList: (1, 1, 2, 3, 5, 3, 2, 1, 1)
indexOf (1): 0
lastIndexOf (1): 8
indexOf (2): 2
lastIndexOf (2): 6
indexOf (3): 3
lastIndexOf (3): 5
indexOf (5): 4
lastIndexOf (5): 4

Production

ArrayList àArray

Prototype: Object () toArray ()
Paramètres: NÉANT
Valeur de retour: Object () => un tableau. Ce tableau renvoyé contient tous les éléments de la liste dans un ordre approprié.
Description: Convertit la liste donnée en un tableau.

Prototype: T () toArray (T () a)

Paramètres: a => Array pour stocker les éléments de la liste. Si la taille du tableau n'est pas suffisante pour les éléments de liste, un autre tableau du même type que a est créé pour stocker les éléments.

Valeur de retour: T () => Tableau contenant tous les éléments de la liste.
Description: Convertit la liste donnée en un tableau du type donné par a.

Des exceptions: ArrayStoreException => S'il y a une discordance dans le type d'exécution du tableau et le type d'exécution ou le supertype de ses éléments.
NullPointerException => Le tableau donné est nul

Le programme Java ci-dessous illustre la méthode toArray de ArrayList.

import java.util.*; public class Main { public static void main(String() args) { // define and initialize ArrayList ArrayList intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); // print ArrayList System.out.println('ArrayList: ' + intList); //declare array Integer myArray() = new Integer(intList.size()); //use toArray method to convert ArrayList to Array myArray = intList.toArray(myArray); //print the Array System.out.println('Array from ArrayList:' + Arrays.toString(myArray)); } }

Production:

ArrayList: (10, 20, 30, 40, 50)
Tableau de ArrayList: (10, 20, 30, 40, 50)

Sortie - toArray ArrayList

Clone ArrayList

Prototype: Clone d'objet ()
Paramètres: NÉANT
Valeur de retour: Object => Clone de l'instance ArrayList.
Description: Crée une copie superficielle de la ArrayList donnée.

import java.util.ArrayList; public class Main { public static void main(String a()){ ArrayList fruitsList = new ArrayList(); //Adding elements to the ArrayList fruitsList.add('Apple'); fruitsList.add('Orange'); fruitsList.add('Melon'); fruitsList.add('Grapes'); System.out.println('Original ArrayList: '+fruitsList); ArrayList clone_list = (ArrayList)fruitsList.clone(); System.out.println('Cloned ArrayList: '+ clone_list); //add one elmeent & remove one element from original arraylist fruitsList.add('Mango'); fruitsList.remove('Orange'); //print original and cloned ArrayList again System.out.println('
Original ArrayList after add & remove:'+fruitsList); System.out.println('Cloned ArrayList after original changed:'+clone_list); } }

Production:

ArrayList d'origine: (Pomme, Orange, Melon, Raisins)
ArrayList cloné: (Apple, Orange, Melon, Grapes)
ArrayList d'origine après ajout et suppression: (Apple, Melon, Grapes, Mango)
ArrayList clonée après la modification de l'original: (Apple, Orange, Melon, Grapes)

sortie - clone arraylist

À partir de la sortie du programme ci-dessus, vous pouvez voir que l'ArrayList cloné est une copie superficielle de l'ArrayList d'origine. Cela signifie que lorsque la ArrayList d'origine est modifiée, ces modifications ne sont pas reflétées dans la ArrayList clonée car elles ne partagent pas les emplacements mémoire de chaque élément.

Pour créer une copie complète de Array, l'ArrayList d'origine doit être parcourue et chacun de ses éléments doit être copié dans l'ArrayList de destination.

Sous-liste ArrayList

Prototype: Liste des sous-listes (int fromIndex, int toIndex)
Paramètres: fromIndex => Index de départ de la plage (inclus)
toIndex => Index de fin de la plage (exclusif)
Valeur de retour: List => Sous-liste de la liste dans la plage donnée.

Description: Renvoie une sous-liste entre une plage donnée, de l'index à l'index pour la liste donnée. Notez que cette sous-liste ou la vue de la liste dans la plage donnée prend en charge toutes les opérations prises en charge par la liste. Aucune vue n'est renvoyée si fromIndex = toIndex.

Des exceptions: IndexOutOfBoundsException => Lancé lorsque toIndex est hors de portée.
IllegalArgumentException => Si fromIndex> toIndex, c'est-à-dire que les indices sont dans le désordre.

Voyons un exemple de la méthode subList.

import java.util.ArrayList; import java.util.List; class Main{ public static void main(String a()){ //create and initialize the ArrayList ArrayList intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); intList.add(30); intList.add(35); intList.add(40); intList.add(45); intList.add(50); //print the ArrayList System.out.println('Original ArrayList: '+intList); //create a sublist for the given ArrayList ArrayList sub_ArrayList = new ArrayList(intList.subList(2, 6)); //print the sublist System.out.println('Sublist of given ArrayList: '+sub_ArrayList); } }

Production:

ArrayList d'origine: (5, 10, 15, 20, 25, 30, 35, 40, 45, 50)
Sous-liste de ArrayList donnée: (15, 20, 25, 30)

Production

ArrayList conserverAll

Prototype: booléen retentionAll (Collection c)
Paramètres: c => Collection avec des éléments à conserver dans la liste.
Valeur de retour: true => Si le ArrayList a changé suite à l'opération.
Description: Conserve les éléments de la liste qui correspondent aux éléments de la collection donnée c.

Des exceptions: ClassCastException => Le type de collection et le type de liste ne correspondent pas
NullPointerException => La collection donnée est nulle ou la liste contient un élément nul et la collection n'autorise pas les valeurs nulles.

Le programme suivant illustre la méthode retentionAll.

import java.util.*; class Main{ public static void main(String args()){ //create and initialize ArrayList ArrayList colorsList=new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print the ArrayList System.out.println('Original ArrayList:' + colorsList); //define another collection ArrayList color_collection=new ArrayList(); color_collection.add('Red'); color_collection.add('Blue'); System.out.println('Collection elements to be retained in the list:' + color_collection); //call retainAll method with above collection as an argument colorsList.retainAll(color_collection); //print the ArrayList after retainAll call. System.out.println('ArrayList after retainAll call:' + colorsList); } }

Production:

ArrayList d’origine: (Rouge, Vert, Bleu, Jaune)
Éléments de la collection à conserver dans la liste: (Rouge, Bleu)
ArrayList après l'appel de retentionAll: (Red, Blue)

Output - méthode retailAll

Itérateur ArrayList

Prototype: Itérateur itérateur ()
Paramètres: NÉANT
Valeur de retour: Iterator => itérateur sur les éléments de la liste.
Description: Renvoie un itérateur pour parcourir les éléments de la liste dans la séquence appropriée.

ArrayList listIterator

JE.

Prototype: ListIterator listIterator ()
Paramètres: NÉANT
Valeur de retour: ListIterator => listIterator sur les éléments de la liste.
Description: Renvoie un itérateur de liste pour parcourir les éléments de la liste donnée.

II.

Prototype: ListIterator listIterator (index int)
Paramètres: index => Position du premier élément dans le listIterator.
Valeur de retour: ListIterator => ListIterator pour la liste de l'index spécifié.
Description: Renvoie l'itérateur de liste à partir de la position spécifiée «index» pour parcourir les éléments de la liste donnée.
Des exceptions: IndexOutOfBoundsException => L'index donné est hors de portée.

Exemple de méthodes iterator () et listIterator ().

import java.util.*; class Main{ public static void main(String args()){ //create ArrayList and initialize it ArrayList cities=new ArrayList(); cities.add('Mumbai'); cities.add('Pune'); cities.add('Hyderabad'); cities.add('Delhi'); //use iterator() method to traverse through the list System.out.println('List contents using Iterator () method:'); Iterator iter=cities.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } //use listIterator() method to traverse through the list System.out.println('

List contents using listIterator () method:'); ListIterator list_iter=cities.listIterator(); while(list_iter.hasNext()) { System.out.print(list_iter.next() + ' '); } } }

Production:

Lister le contenu en utilisant la méthode Iterator ():
Mumbai Pune Hyderabad Delhi
Répertoriez le contenu à l'aide de la méthode listIterator ():
Mumbai Pune Hyderabad Delhi

Sortie - Méthodes Iterator et listIterator

Ajouter un tableau à ArrayList en Java

ArrayList prend en charge la méthode addAll pour ajouter des éléments de la collection à ArrayList. De la même manière, vous pouvez également ajouter un Array à ArrayList. Cela se fait en utilisant la méthode «Collections.addAll».

Exemple d'ajout d'un Array à ArrayList.

import java.util.*; class Main{ public static void main(String args()){ //create an ArrayList ArrayList city_List=new ArrayList(); //add elements to the ArrayList using add method city_List.add('Delhi'); city_List.add('Mumbai'); city_List.add('Chennai'); city_List.add('Kolkata'); //print ArrayList System.out.println('
Initial ArrayList :' + city_List); //define an array. String() myArray = new String(){'Cochin', 'Goa'}; //add the array to the ArrayList Collections.addAll(city_List,myArray); //print the ArrayList System.out.println('
ArrayList after adding array :' + city_List); } }

Production:

ArrayList initiale: (Delhi, Mumbai, Chennai, Kolkata)
ArrayList après l'ajout du tableau: (Delhi, Mumbai, Chennai, Kolkata, Cochin, Goa)

sortie - Ajouter un tableau à un tableau en Java

Trier ArrayList en Java

ArrayList utilise la méthode Collections.sort pour trier ses éléments. Par défaut, la liste est triée par ordre croissant par la méthode Collections.sort. Si le ArrayList doit être trié par ordre décroissant, vous devez fournir un paramètre à la méthode de tri 'Collections.reverseOrder ()'.

Vous trouverez ci-dessous un programme pour trier une ArrayList par ordre croissant et décroissant:

import java.util.*; public class Main { public static void main(String args()){ //Create and initialize an ArrayList ArrayList colorsList = new ArrayList(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Yellow'); //print initial ArrayList System.out.println('Initial ArrayList:' + colorsList); //sort ArrayList in ascending order Collections.sort(colorsList); //print sorted ArrayList System.out.println('
ArrayList sorted in ascending order:'); System.out.println(colorsList); //sort ArrayList in reverse(desending) order Collections.sort(colorsList, Collections.reverseOrder()); //print sorted list System.out.println('
ArrayList sorted in descending order:'); System.out.println(colorsList); } }

Production:

ArrayList initiale: (rouge, vert, bleu, jaune)
ArrayList trié par ordre croissant:
(Bleu, vert, rouge, jaune)
ArrayList trié par ordre décroissant:
(Jaune, rouge, vert, bleu)

Sortie - tri arraylist en Java

Dans le cas où ArrayList contient d'autres objets de classe comme éléments, vous pouvez utiliser les interfaces Comparable et Comparator. Plus de détails sur les interfaces seront traités dans nos prochains tutoriels.

Inverser une ArrayList en Java

Vous pouvez également inverser une ArrayList en Java. Une méthode pour ce faire consiste à utiliser la méthode traditionnelle de parcourir ArrayList dans l'ordre inverse et de copier chaque élément dans un nouveau ArrayList.

Une autre méthode consiste à utiliser la classe Collections qui fournit la méthode «reverse» utilisée pour inverser une collection.

Le programme pour inverser une ArrayList à l'aide de la classe Collections est donné ci-dessous.

import java.io.*; import java.util.*; public class Main { public static void main(String() args) { // create and initialize an ArrayList ArrayList oddList = new ArrayList(); oddList.add(1); oddList.add(3); oddList.add(5); oddList.add(7); oddList.add(9); System.out.print('Initial ArrayList: ' + oddList); // use Collections.reverse method to reverse the ArrayList Collections.reverse(oddList); //print the ArrayList System.out.print('
Reversed ArrayList: ' + oddList); } }

Production:

ArrayList initiale: (1, 3, 5, 7, 9)
ArrayList inversé: (9, 7, 5, 3, 1)

Sortie - Reverse et ArrayList

Supprimer les doublons d'une ArrayList en Java

Pour supprimer les doublons de ArrayList, vous pouvez à nouveau recourir à la méthode traditionnelle d'utilisation d'un itérateur pour parcourir ArrayList et stocker uniquement la première occurrence de l'élément dans un ArrayList différent.

Une autre méthode consiste à utiliser la méthode «distinct ()» de la classe stream (). Cette méthode retourne un flux d'éléments distincts. La fonction stream () est disponible en Java à partir de Java 8.

L'implémentation de la méthode stream () .distinct () est donnée ci-dessous:

import java.util.*; import java.util.stream.Collectors; public class Main { public static void main(String() args) { // Create an ArrayList of numbers ArrayList numList = new ArrayList (Arrays.asList(1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)); //print the original ArrayList System.out.println('Original ArrayList:' + numList); //Use Java 8 stream().distinct() method to remove duplicates from the list List distinctList = numList.stream().distinct().collect(Collectors.toList()); //print the new list System.out.println('ArrayList without duplicates:' + distinctList); } }

Production:

ArrayList d'origine: (1, 2, 3, 1, 3, 5, 5, 6, 6, 7, 7, 8, 8)
ArrayList sans doublons: (1, 2, 3, 5, 6, 7, 8)

Sortie - Supprimer les doublons de ArrayList

Mélanger (randomiser) une ArrayList en Java

Vous pouvez également «mélanger» ou randomiser les éléments ArrayList. Cela se fait en utilisant la méthode Collections.shuffle (). En utilisant cette méthode, vous pouvez mélanger ArrayList avec les paramètres par défaut ou fournir une fonction random () qui randomisera les éléments en fonction de la valeur aléatoire fournie.

Un programme Java pour y parvenir est donné ci-dessous.

import java.util.*; public class Main { public static void main(String() args) { //create and initialize a String ArrayList ArrayList strlist = new ArrayList(); strlist.add('east'); strlist.add('west'); strlist.add('north'); strlist.add('south'); strlist.add('southwest'); strlist.add('northeast'); //print the original list System.out.println('Original ArrayList : 
' + strlist); //shuffle the ArrayList without random function Collections.shuffle(strlist); System.out.println('
Shuffled ArrayList without Random() : 
' + strlist); // shuffle the ArrayList with random() function Collections.shuffle(strlist, new Random()); System.out.println('
Shuffled ArrayList with Random() : 
' + strlist); // use random (2) to shuffle the ArrayList Collections.shuffle(strlist, new Random(2)); System.out.println('
Shuffled ArrayList with Random(2) : 
' + strlist); } }

Production:

ArrayList d'origine: (est, ouest, nord, sud, sud-ouest, nord-est) ArrayList mélangé sans aléatoire (): (nord, nord-est, est, sud-ouest, sud, ouest)
ArrayList aléatoire avec Random (): (sud, est, nord, nord-est, ouest, sud-ouest)
ArrayList mélangé avec aléatoire (2): (sud-ouest, sud, est, nord-est, nord, ouest)

Sortie - Shuffle (Randomize) an ArrayList

Questions fréquemment posées

Q # 1) Quelle est la différence entre les conteneurs homogènes et hétérogènes en Java?

Répondre: Les conteneurs homogènes contiennent des objets / éléments du même type. D'autre part, les conteneurs hétérogènes ont des objets de type mixte.

Q # 2) ArrayList en Java est-il hétérogène?

Répondre: Oui. Étant donné que les ArrayLists prennent en charge les génériques et donc l'effacement de type, il peut contenir des objets mixtes lorsqu'il est implémenté en tant que ArrayList générique.

Q # 3) ArrayList peut-il stocker des int?

Répondre: Non. ArrayLists ne peut pas stocker de valeurs comme int mais il peut stocker des objets Integer car ArrayLists ne peut contenir que des objets. Ainsi, pour stocker les types primitifs, vous devez utiliser des classes wrapper telles que Integer pour ints.

Q # 4) Que se passe-t-il lorsque ArrayList est plein?

Répondre: Chaque objet ArrayList a une fonctionnalité nommée «capacité». Lorsque la ArrayList est pleine, la capacité de la ArrayList augmente automatiquement pour faire de la place pour plus d'éléments.

Q # 5) Quelle est la différence entre la méthode removeAll et retentionAll dans ArrayList?

Répondre: Les méthodes ArrayList «removeAll» et «retentionAll» présentent un comportement opposé.

Alors que la méthode removeAll supprime tous les éléments de la liste qui correspondent à la collection passée en argument à cette méthode, retentionAll, en revanche, conserve tous les éléments de la liste qui correspondent à celui de la collection.

Conclusion

Dans ce didacticiel, nous avons discuté en détail des méthodes ArrayList avec un exemple.

Nous avons également examiné certains cas particuliers comme l'ajout d'éléments au début de la liste. Nous avons également discuté d'autres opérations sur ArrayList comme le tri, l'inversion et la lecture aléatoire de ArrayList.

Dans notre prochain didacticiel, nous aborderons certaines des conversions ArrayList.

=> Regardez la série de formation Java simple ici.

Méthodes ArrayList en Java - Tutoriel avec des programmes d'exemple