logo

TechCodeview

Interface de liste en Java avec exemples

L'interface List en Java fournit un moyen de stocker la collection ordonnée. C'est une interface enfant de Collection . Il s'agit d'une collection ordonnée d'objets dans laquelle des valeurs en double peuvent être stockées. Puisque List préserve l’ordre d’insertion, il permet l’accès positionnel et l’insertion d’éléments.

Table des matières

Interface de liste en Java

L'interface List se trouve dans le package java.util et hérite de l'interface Collection. C'est une fabrique de l'interface ListIterator. Grâce au ListIterator, nous pouvons parcourir la liste dans les sens avant et arrière. Les classes d'implémentation de l'interface List sont ArrayList, LinkedList, Stack et Vector. ArrayList et LinkedList sont largement utilisés dans la programmation Java. La classe Vector est obsolète depuis Java 5.



Liste et ArrayList dans Java Collection Framework

Déclaration de l'interface de liste Java 

public interface List extends Collection ;>

Développons la création d'objets ou d'instances dans une classe List. Depuis Liste est un interface , les objets de type liste ne peuvent pas être créés. Nous avons toujours besoin d'une classe qui implémente cela Liste afin de créer un objet. Et aussi, après l'introduction de Génériques dans Java 1.5, il est possible de restreindre le type d'objet pouvant être stocké dans la Liste. Tout comme plusieurs autres « interfaces » définies par l’utilisateur implémentées par des « classes » définies par l’utilisateur, Liste est une « interface », implémentée par le Liste des tableaux classe, prédéfinie dans java.util emballer.

Syntaxe de la liste Java

Ce type de liste sûre peut être défini comme :

List list = new ArrayList ();>

Note: Obj est le type de l'objet à stocker dans List

Exemple de liste Java

Java




// Java program to Demonstrate List Interface> > // Importing all utility classes> import> java.util.*;> > // Main class> // ListDemo class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> > >// Creating an object of List interface> >// implemented by the ArrayList class> >List l1 =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom inputs> > >l1.add(>0>,>1>);> >l1.add(>1>,>2>);> > >// Print the elements inside the object> >System.out.println(l1);> > >// Now creating another object of the List> >// interface implemented ArrayList class> >// Declaring object of integer type> >List l2 =>new> ArrayList();> > >// Again adding elements to object of List interface> >// Custom inputs> >l2.add(>1>);> >l2.add(>2>);> >l2.add(>3>);> > >// Will add list l2 from 1 index> >l1.addAll(>1>, l2);> > >System.out.println(l1);> > >// Removes element from index 1> >l1.remove(>1>);> > >// Printing the updated List 1> >System.out.println(l1);> > >// Prints element at index 3 in list 1> >// using get() method> >System.out.println(l1.get(>3>));> > >// Replace 0th element with 5> >// in List 1> >l1.set(>0>,>5>);> > >// Again printing the updated List 1> >System.out.println(l1);> >}> }> 

>

>

Sortir 

[1, 2] [1, 1, 2, 3, 2] [1, 2, 3, 2] 2 [5, 2, 3, 2]>

Effectuons maintenant diverses opérations à l’aide de List Interface pour mieux comprendre celle-ci. Nous discuterons des opérations suivantes répertoriées ci-dessous et plus tard de leur implémentation via des codes Java propres.

Opérations dans une interface de liste Java

Puisque List est une interface, elle ne peut être utilisée qu’avec une classe qui implémente cette interface. Voyons maintenant comment effectuer quelques opérations fréquemment utilisées sur la liste.

  • Opération 1 : Ajout d'éléments à la classe List à l'aide de la méthode add()
  • Opération 2 : Mise à jour des éléments dans la classe List à l'aide de la méthode set()
  • Opération 3 : Recherche d'éléments à l'aide des méthodes indexOf(), lastIndexOf
  • Opération 4 : Suppression d'éléments à l'aide de la méthode Remove()
  • Opération 5 : Accéder aux éléments de la classe List à l'aide de la méthode get()
  • Opération 6 : Vérifier si un élément est présent dans la classe List à l'aide de la méthode contain()

Discutons maintenant des opérations individuellement et implémentons-les dans le code pour en avoir une meilleure maîtrise.

1. Ajout d'éléments à la classe List à l'aide de méthode ajouter()

Afin d'ajouter un élément à la liste, nous pouvons utiliser le ajouter() méthode. Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres.

Paramètres: Il faut 2 paramètres, à savoir :

  • ajouter (Objet): Cette méthode est utilisée pour ajouter un élément à la fin de la Liste.
  • ajouter (index int, objet): Cette méthode est utilisée pour ajouter un élément à un index spécifique dans la liste

Exemple:

Java

différence tigre lion




// Java Program to Add Elements to a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >// Custom elements> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'For'>);> > >// Print all the elements inside the> >// List interface object> >System.out.println(al);> >}> }> 

>

>

Sortir 

[Geeks, For, Geeks]>

2. Mise à jour des éléments

Après avoir ajouté les éléments, si l'on souhaite changer l'élément, cela peut être fait en utilisant le ensemble() méthode. Puisque List est indexé, l'élément que l'on souhaite modifier est référencé par l'index de l'élément. Par conséquent, cette méthode prend un index et l'élément mis à jour qui doit être inséré à cet index.

Exemple:

Java




// Java Program to Update Elements in a List> > // Importing utility classes> import> java.util.*;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface> >List al =>new> ArrayList();> > >// Adding elements to object of List class> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> >al.add(>1>,>'Geeks'>);> > >// Display theinitial elements in List> >System.out.println(>'Initial ArrayList '> + al);> > >// Setting (updating) element at 1st index> >// using set() method> >al.set(>1>,>'For'>);> > >// Print and display the updated List> >System.out.println(>'Updated ArrayList '> + al);> >}> }> 

>

>

Sortir 

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>

3. Recherche d'éléments

La recherche d'éléments dans l'interface List est une opération courante dans la programmation Java. L'interface Liste propose plusieurs méthodes pour rechercher des éléments, telles que Indice de() , dernierIndexOf() méthodes.

La méthode indexOf() renvoie l'index de la première occurrence d'un élément spécifié dans la liste, tandis que la méthode lastIndexOf() renvoie l'index de la dernière occurrence d'un élément spécifié.

Paramètres:

  • indexDe(élément) : Renvoie l'index de la première occurrence de l'élément spécifié dans la liste, ou -1 si l'élément n'est pas trouvé
  • lastIndexOf (élément) : Renvoie l'index de la dernière occurrence de l'élément spécifié dans la liste, ou -1 si l'élément n'est pas trouvé

Exemple:

Java


Go contre Mo



import> java.util.ArrayList;> import> java.util.List;> > public> class> ListExample {> >public> static> void> main(String[] args)> >{> >// create a list of integers> >List numbers =>new> ArrayList();> > >// add some integers to the list> >numbers.add(>1>);> >numbers.add(>2>);> >numbers.add(>3>);> >numbers.add(>2>);> > >// use indexOf() to find the first occurrence of an> >// element in the list> >int> index = numbers.indexOf(>2>);> >System.out.println(> >'The first occurrence of 2 is at index '> >+ index);> > >// use lastIndexOf() to find the last occurrence of> >// an element in the list> >int> lastIndex = numbers.lastIndexOf(>2>);> >System.out.println(> >'The last occurrence of 2 is at index '> >+ lastIndex);> >}> }> 

>

>

Sortir 

The first occurrence of 2 is at index 1 The last occurrence of 2 is at index 3>

4. Suppression d'éléments

Afin de supprimer un élément d'une liste, nous pouvons utiliser le retirer() méthode. Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont:

Paramètres:

  • supprimer (Objet): Cette méthode est utilisée pour supprimer simplement un objet de la liste. S'il existe plusieurs objets de ce type, la première occurrence de l'objet est supprimée.
  • supprimer (index int): Puisqu'une liste est indexée, cette méthode prend une valeur entière qui supprime simplement l'élément présent à cet index spécifique dans la liste. Après avoir supprimé l'élément, tous les éléments sont déplacés vers la gauche pour remplir l'espace et les index des objets sont mis à jour.

Exemple:

Java




// Java Program to Remove Elements from a List> > // Importing List and ArrayList classes> // from java.util package> import> java.util.ArrayList;> import> java.util.List;> > // Main class> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> > >// Creating List class object> >List al =>new> ArrayList();> > >// Adding elements to the object> >// Custom inputs> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding For at 1st indexes> >al.add(>1>,>'For'>);> > >// Print the initialArrayList> >System.out.println(>'Initial ArrayList '> + al);> > >// Now remove element from the above list> >// present at 1st index> >al.remove(>1>);> > >// Print the List after removal of element> >System.out.println(>'After the Index Removal '> + al);> > >// Now remove the current object from the updated> >// List> >al.remove(>'Geeks'>);> > >// Finally print the updated List now> >System.out.println(>'After the Object Removal '> >+ al);> >}> }> 

>

>

Sortir 

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>

5. Accéder aux éléments

Afin d'accéder à un élément de la liste, nous pouvons utiliser le obtenir() méthode, qui renvoie l'élément à l'index spécifié

Paramètres:

get(int index) : Cette méthode renvoie l'élément à l'index spécifié dans la liste.

Exemple:

Java


java datetime locale



// Java Program to Access Elements of a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Accessing elements using get() method> >String first = al.get(>0>);> >String second = al.get(>1>);> >String third = al.get(>2>);> > >// Printing all the elements inside the> >// List interface object> >System.out.println(first);> >System.out.println(second);> >System.out.println(third);> >System.out.println(al);> >}> }> 

>

>

Sortir 

Geeks For Geeks [Geeks, For, Geeks]>

6. Vérifier si un élément est présent dans la liste

Afin de vérifier si un élément est présent dans la liste, on peut utiliser la contient() méthode. Cette méthode renvoie vrai si l'élément spécifié est présent dans la liste, sinon elle renvoie faux.

Paramètres:

contain(Object) : Cette méthode prend un seul paramètre, l'objet à vérifier s'il est présent dans la liste.

Exemple:

Java




// Java Program to Check if an Element is Present in a List> > // Importing all utility classes> import> java.util.*;> > // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Creating an object of List interface,> >// implemented by ArrayList class> >List al =>new> ArrayList();> > >// Adding elements to object of List interface> >al.add(>'Geeks'>);> >al.add(>'For'>);> >al.add(>'Geeks'>);> > >// Checking if element is present using contains()> >// method> >boolean> isPresent = al.contains(>'Geeks'>);> > >// Printing the result> >System.out.println(>'Is Geeks present in the list? '> >+ isPresent);> >}> }> 

>

>

Sortir 

Is Geeks present in the list? true>

Complexité de l'interface de liste en Java

Opération

Complexité temporelle

Complexité spatiale

Ajout d'un élément dans l'interface de liste

O(1)

O(1)

Supprimer un élément de l'interface de liste

SUR)

SUR)

Remplacer l'élément dans l'interface de liste

SUR)

SUR)

Interface de liste de parcours

SUR)

SUR)

Itération sur l'interface de liste en Java

Jusqu'à présent, nous avons une très petite taille d'entrée et nous effectuons des opérations manuellement pour chaque entité. Voyons maintenant différentes manières par lesquelles nous pouvons parcourir la liste pour les faire fonctionner sur un ensemble d'échantillons plus large.

Méthodes : Il existe plusieurs façons de parcourir la liste. Les méthodes les plus connues consistent à utiliser les méthodes de base pour la boucle en combinaison avec un méthode get() pour obtenir l'élément à un index spécifique et le avancé pour une boucle .

Exemple:

Java




// Java program to Iterate the Elements> // in an ArrayList> > // Importing java utility classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// main driver method> >public> static> void> main(String args[])> >{> >// Creating an empty Arraylist of string type> >List al =>new> ArrayList();> > >// Adding elements to above object of ArrayList> >al.add(>'Geeks'>);> >al.add(>'Geeks'>);> > >// Adding element at specified position> >// inside list object> >al.add(>1>,>'For'>);> > >// Using for loop for iteration> >for> (>int> i =>0>; i // Using get() method to // access particular element System.out.print(al.get(i) + ' '); } // New line for better readability System.out.println(); // Using for-each loop for iteration for (String str : al) // Printing all the elements // which was inside object System.out.print(str + ' '); } }> 

>

Unix contre Windows 

>

Sortir 

Geeks For Geeks Geeks For Geeks>

Méthodes de l'interface de liste

Étant donné que le concept principal derrière les différents types de listes est le même, l'interface de liste contient les méthodes suivantes :

Méthode

Description
ajouter (int index, élément) Cette méthode est utilisée avec Java List Interface pour ajouter un élément à un index particulier dans la liste. Lorsqu'un seul paramètre est passé, il ajoute simplement l'élément à la fin de la liste.
addAll (index int, collection collection) Cette méthode est utilisée avec List Interface en Java pour ajouter tous les éléments de la collection donnée à la liste. Lorsqu'un seul paramètre est passé, il ajoute tous les éléments de la collection donnée à la fin de la liste.
taille() Cette méthode est utilisée avec Java List Interface pour renvoyer la taille de la liste.
clair() Cette méthode est utilisée pour supprimer tous les éléments de la liste. Cependant, la référence de la liste créée est toujours stockée.
supprimer (index int) Cette méthode supprime un élément de l'index spécifié. Il décale les éléments suivants (le cas échéant) vers la gauche et diminue leurs index de 1.
supprimer (élément) Cette méthode est utilisée avec Java List Interface pour supprimer la première occurrence de l'élément donné dans la liste.
obtenir (index int) Cette méthode renvoie les éléments à l'index spécifié.
set (int index, élément) Cette méthode remplace les éléments d'un index donné par le nouvel élément. Cette fonction renvoie l'élément qui vient d'être remplacé par un nouvel élément.
indexDe(élément) Cette méthode renvoie la première occurrence de l'élément donné ou -1 si l'élément n'est pas présent dans la liste.
dernierIndexDe(élément) Cette méthode renvoie la dernière occurrence de l'élément donné ou -1 si l'élément n'est pas présent dans la liste.
est égal à (élément) Cette méthode est utilisée avec Java List Interface pour comparer l'égalité de l'élément donné avec les éléments de la liste.
code de hachage() Cette méthode est utilisée avec List Interface en Java pour renvoyer la valeur du hashcode de la liste donnée.
est vide() Cette méthode est utilisée avec Java List Interface pour vérifier si la liste est vide ou non. Il renvoie vrai si la liste est vide, sinon faux.
contient (élément) Cette méthode est utilisée avec List Interface en Java pour vérifier si la liste contient ou non l'élément donné. Il renvoie vrai si la liste contient l'élément.
contientTout (Collection collection) Cette méthode est utilisée avec Java List Interface pour vérifier si la liste contient toute la collection d'éléments.
trier (composition de comparaison) Cette méthode est utilisée avec List Interface en Java pour trier les éléments de la liste en fonction des valeurs données. comparateur .

Liste Java vs ensemble

L’interface List et l’interface Set héritent de l’interface Collection. Il existe cependant certaines différences entre eux.

Liste

Ensemble
La liste est une séquence ordonnée. L'ensemble est une séquence non ordonnée.
La liste autorise les éléments en double Set n'autorise pas les éléments en double.
Les éléments par leur position sont accessibles. L'accès à la position aux éléments n'est pas autorisé.
Plusieurs éléments nuls peuvent être stockés. L'élément null ne peut être stocké qu'une seule fois.
Les implémentations de liste sont ArrayList, LinkedList, Vector, Stack Les implémentations d'ensemble sont HashSet, LinkedHashSet.

Association de classes avec une interface de liste Java

Discutons maintenant des classes qui implémentent l'interface List pour lesquelles nous devons d'abord nous référer à la représentation picturale ci-dessous pour avoir une meilleure compréhension de l'interface List. C'est le suivant :

Liste abstraite , CopyOnWriteArrayList , et le RésuméSequentialList sont les classes qui implémentent l’interface List. Une fonctionnalité distincte est implémentée dans chacune des classes mentionnées. Ils sont les suivants :

  1. Liste des résumés : Cette classe est utilisée pour implémenter une liste non modifiable, pour laquelle il suffit d'étendre cette classe AbstractList et d'implémenter uniquement la obtenir() et le taille() méthodes.
  2. CopieOnWriteArrayList : Cette classe implémente l'interface de liste. Il s'agit d'une version améliorée de Liste des tableaux dans lequel toutes les modifications (ajouter, définir, supprimer, etc.) sont implémentées en faisant une nouvelle copie de la liste.
  3. Liste séquentielle abstraite : Cette classe implémente le Interface de collecte et la classe AbstractCollection. Cette classe est utilisée pour implémenter une liste non modifiable, pour laquelle il suffit d'étendre cette classe AbstractList et d'implémenter uniquement la obtenir() et le taille() méthodes.

Nous procéderons de cette manière.

  • Liste des tableaux
  • Vecteur
  • Empiler
  • Liste liée

Discutons-en séquentiellement et implémentons-les pour comprendre le fonctionnement des classes avec l'interface List.

1. Liste de tableaux

Une liste de tableaux La classe qui est implémentée dans le framework de collection nous fournit des tableaux dynamiques en Java. Cependant, il peut être plus lent que les tableaux standard, mais peut être utile dans les programmes où de nombreuses manipulations dans le tableau sont nécessaires. Voyons comment créer un objet liste à l'aide de cette classe.

Exemple:

Java




// Java program to demonstrate the> // creation of list object using the> // ArrayList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of ArrayList> >int> n =>5>;> > >// Declaring the List with initial size n> >List arrli =>new> ArrayList(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >arrli.add(i);> > >// Printing elements> >System.out.println(arrli);> > >// Remove element at index 3> >arrli.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(arrli);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(arrli.get(i) + ' '); } }> 

>

>

Sortir 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

2. Vecteur

Vector est une classe implémentée dans le framework de collection qui implémente un tableau d'objets extensible. Vector implémente un tableau dynamique qui signifie qu'il peut s'agrandir ou se réduire selon les besoins. Comme un tableau, il contient des composants accessibles à l’aide d’un index entier. Les vecteurs appartiennent essentiellement aux classes héritées, mais ils sont désormais entièrement compatibles avec les collections. Voyons comment créer un objet liste à l'aide de cette classe.

Exemple:

Java




// Java program to demonstrate the> // creation of list object using the> // Vector class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the vector> >int> n =>5>;> > >// Declaring the List with initial size n> >List v =>new> Vector(n);> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >v.add(i);> > >// Printing elements> >System.out.println(v);> > >// Remove element at index 3> >v.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(v);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(v.get(i) + ' '); } }> 

>

>

Sortir 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

3. Pile

Stack est une classe qui est implémentée dans le framework de collection et étend les modèles de classe vectorielle et implémente le Exemple:

Java

à la méthode de chaîne Java
Exemple:

Java




// Java program to demonstrate the> // creation of list object using the> // Stack class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the stack> >int> n =>5>;> > >// Declaring the List> >List s =>new> Stack();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >s.add(i);> > >// Printing elements> >System.out.println(s);> > >// Remove element at index 3> >s.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(s);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(s.get(i) + ' '); } }> 

>

>

Sortir 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>

4. Liste liée

Exemple:

Java

LinkedList est une classe implémentée dans le framework de collection qui implémente intrinsèquement le Exemple:

Java

Exemple:

Java




// Java program to demonstrate the> // creation of list object using the> // LinkedList class> > import> java.io.*;> import> java.util.*;> > class> GFG {> >public> static> void> main(String[] args)> >{> >// Size of the LinkedList> >int> n =>5>;> > >// Declaring the List with initial size n> >List ll =>new> LinkedList();> > >// Appending the new elements> >// at the end of the list> >for> (>int> i =>1>; i <= n; i++)> >ll.add(i);> > >// Printing elements> >System.out.println(ll);> > >// Remove element at index 3> >ll.remove(>3>);> > >// Displaying the list after deletion> >System.out.println(ll);> > >// Printing elements one by one> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } }> 

>

>

Sortir 

[1, 2, 3, 4, 5] [1, 2, 3, 5] 1 2 3 5>