La liste chaînée fait partie de Cadre de collecte présent dans le package java.util. Cette classe est une implémentation de la structure de données de liste doublement chaînée.
La principale différence entre une liste chaînée normale et une liste doublement chaînée est qu'une liste doublement chaînée contient un pointeur supplémentaire, généralement appelé pointeur précédent, ainsi que le pointeur suivant et les données qui se trouvent dans la liste chaînée unique.
Constructeurs dans la LinkedList :
Afin de créer une LinkedList, nous devons créer un objet de la classe LinkedList. La classe LinkedList se compose de différents constructeurs qui permettent la création éventuelle de la liste. Voici les constructeurs disponibles dans cette classe :
1. LinkedList() : Ce constructeur est utilisé pour créer une liste chaînée vide. Si nous souhaitons créer une LinkedList vide avec le nom ll, alors elle peut être créée comme :
LinkedList ll = new LinkedList();
2. Liste liée (Collection C) : Ce constructeur est utilisé pour créer une liste ordonnée contenant tous les éléments d'une collection spécifiée, tels que renvoyés par l'itérateur de la collection. Si nous souhaitons créer une LinkedList avec le nom ll, alors elle peut être créée comme :
LinkedList ll = new LinkedList(C);
Méthodes pour Java LinkedList :
| Méthode | Description |
|---|---|
| ajouter (index int, élément E) | Cette méthode insère l'élément spécifié à la position spécifiée dans cette liste. |
| ajouter(Et et) | Cette méthode ajoute l'élément spécifié à la fin de cette liste. |
| addAll (int index, Collection c) | Cette méthode insère tous les éléments de la collection spécifiée dans cette liste, en commençant à la position spécifiée. |
| ajouterTout(Collection c) | Cette méthode ajoute tous les éléments de la collection spécifiée à la fin de cette liste, dans l'ordre dans lequel ils sont renvoyés par l'itérateur de la collection spécifiée. |
| ajouterPremier(E e) | Cette méthode insère l'élément spécifié au début de cette liste. |
| ajouterDernier(E e) | Cette méthode ajoute l'élément spécifié à la fin de cette liste. |
| clair() | Cette méthode supprime tous les éléments de cette liste. |
| cloner() | Cette méthode renvoie une copie superficielle de cette LinkedList. |
| contient (Objet o) | Cette méthode renvoie true si cette liste contient l'élément spécifié. |
| descendantItérateur() | Cette méthode renvoie un itérateur sur les éléments de ce deque dans un ordre séquentiel inverse. |
| élément() | Cette méthode récupère mais ne supprime pas la tête (premier élément) de cette liste. |
| obtenir (index int) | Cette méthode renvoie l'élément à la position spécifiée dans cette liste. |
| obtenirPremier() | Cette méthode renvoie le premier élément de cette liste. |
| obtenirDernier() | Cette méthode renvoie le dernier élément de cette liste. |
| indexDe(Objet o) | Cette méthode renvoie l'index de la première occurrence de l'élément spécifié dans cette liste, ou -1 si cette liste ne contient pas l'élément. |
| dernierIndexOf(Objet o) | Cette méthode renvoie l'index de la dernière occurrence de l'élément spécifié dans cette liste, ou -1 si cette liste ne contient pas l'élément. |
| listItérateur (index int) | Cette méthode renvoie un itérateur de liste des éléments de cette liste (dans le bon ordre), en commençant à la position spécifiée dans la liste. |
| offre(E e) | Cette méthode ajoute l'élément spécifié comme queue (dernier élément) de cette liste. |
| offrePremier(E et) | Cette méthode insère l'élément spécifié au début de cette liste. |
| offreDernier(E e) | Cette méthode insère l'élément spécifié à la fin de cette liste. |
| coup d'oeil() | Cette méthode récupère mais ne supprime pas la tête (premier élément) de cette liste. |
| coup d'oeilPremier() | Cette méthode récupère, mais ne supprime pas, le premier élément de cette liste, ou renvoie null si cette liste est vide. |
| coup d'oeilDernier() | Cette méthode récupère, mais ne supprime pas, le dernier élément de cette liste, ou renvoie null si cette liste est vide. |
| sondage() | Cette méthode récupère et supprime la tête (premier élément) de cette liste. |
| sondagePremier() | Cette méthode récupère et supprime le premier élément de cette liste, ou renvoie null si cette liste est vide. |
| sondageDernier() | Cette méthode récupère et supprime le dernier élément de cette liste, ou renvoie null si cette liste est vide. |
| populaire() | Cette méthode extrait un élément de la pile représentée par cette liste. |
| pousser (E et) | Cette méthode pousse un élément sur la pile représentée par cette liste. |
| retirer() | Cette méthode récupère et supprime la tête (premier élément) de cette liste. |
| supprimer (index int) | Cette méthode supprime l'élément à la position spécifiée dans cette liste. |
| supprimer (Objet o) | Cette méthode supprime la première occurrence de l'élément spécifié de cette liste s'il est présent. |
| supprimerPremier() | Cette méthode supprime et renvoie le premier élément de cette liste. |
| supprimerPremièreOccurrence(Objet o) | Cette méthode supprime la première occurrence de l'élément spécifié dans cette liste (lors du parcours de la liste de la tête à la queue). |
| supprimerDernier() | Cette méthode supprime et renvoie le dernier élément de cette liste. |
| supprimerDernièreOccurrence(Objet o) | Cette méthode supprime la dernière occurrence de l'élément spécifié dans cette liste (lors du parcours de la liste de la tête à la queue). |
| set (index int, élément E) | Cette méthode remplace l'élément à la position spécifiée dans cette liste par l'élément spécifié. |
| taille() | Cette méthode renvoie le nombre d'éléments dans cette liste. |
| séparateur() | Cette méthode crée un Spliterator à liaison tardive et à échec rapide sur les éléments de cette liste. |
| versArray() | Cette méthode renvoie un tableau contenant tous les éléments de cette liste dans le bon ordre (du premier au dernier élément). |
| versTableau(T[] a) | Cette méthode renvoie un tableau contenant tous les éléments de cette liste dans le bon ordre (du premier au dernier élément) ; le type d'exécution du tableau renvoyé est celui du tableau spécifié. |
| àChaîne() | Cette méthode renvoie une chaîne contenant tous les éléments de cette liste dans le bon ordre (du premier au dernier élément), chaque élément est séparé par des virgules et la chaîne est placée entre crochets. |
Ci-dessous la mise en œuvre des opérations ci-dessus :
Java
// Java Program to Demonstrate> // Implementation of LinkedList> // class> > // Importing required classes> import> java.util.*;> > // Main class> public> class> GFG {> > >// Driver code> >public> static> void> main(String args[])> >{> >// Creating object of the> >// class linked list> >LinkedList ll =>new> LinkedList();> > >// Adding elements to the linked list> >ll.add(>'A'>);> >ll.add(>'B'>);> >ll.addLast(>'C'>);> >ll.addFirst(>'D'>);> >ll.add(>2>,>'E'>);> > >System.out.println(ll);> > >ll.remove(>'B'>);> >ll.remove(>3>);> >ll.removeFirst();> >ll.removeLast();> > >System.out.println(ll);> >}> }> |
>
>Sortir
[D, A, E, B, C] [A]>
Dans l'illustration ci-dessus, AbstractList , CopyOnWriteArrayList et AbstractSequentialList sont les classes qui implémentent l'interface de liste. Une fonctionnalité distincte est implémentée dans chacune des classes mentionnées. Ils sont:
- AbstractList : 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 les méthodes get() et size(). CopyOnWriteArrayList : Cette classe implémente l'interface de liste. Il s'agit d'une version améliorée d'ArrayList dans laquelle toutes les modifications (ajouter, définir, supprimer, etc.) sont implémentées en créant une nouvelle copie de la liste.
Effectuer diverses opérations sur LinkedList :
- Ajout d'éléments
- Mise à jour des éléments
- Suppression d'éléments
- Itérer sur les éléments
- Vers un tableau();
- Taille();
- supprimer Premier();
- supprimer le dernier();
Opération 1 : Ajout d'éléments
Afin d'ajouter un élément à une ArrayList, nous pouvons utiliser la méthode add() . Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont:
- add(Object) : Cette méthode est utilisée pour ajouter un élément à la fin de la LinkedList. add(int index, Object) : Cette méthode est utilisée pour ajouter un élément à un index spécifique dans la LinkedList.
Ci-dessous la mise en œuvre de l'opération ci-dessus :
Java
// Java program to add elements> // to a LinkedList> > import> java.util.*;> > public> class> GFG {> > >public> static> void> main(String args[])> >{> >LinkedList ll =>new> LinkedList();> > >ll.add(>'Geeks'>);> >ll.add(>'Geeks'>);> >ll.add(>1>,>'For'>);> > >System.out.println(ll);> >}> }> |
>
>Sortir
[Geeks, For, Geeks]>
Opération 2 : Changer les éléments
Après avoir ajouté les éléments, si nous souhaitons modifier l'élément, cela peut être fait en utilisant la méthode set() . Puisqu'une LinkedList est indexée, 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.
Ci-dessous la mise en œuvre de l'opération ci-dessus :
Java
// Java program to change elements> // in a LinkedList> > import> java.util.*;> > public> class> GFG {> > >public> static> void> main(String args[])> >{> >LinkedList ll =>new> LinkedList();> > >ll.add(>'Geeks'>);> >ll.add(>'Geeks'>);> >ll.add(>1>,>'Geeks'>);> > >System.out.println(>'Initial LinkedList '> + ll);> > >ll.set(>1>,>'For'>);> > >System.out.println(>'Updated LinkedList '> + ll);> >}> }> |
rhel contre centos
>
>Sortir
Initial LinkedList [Geeks, Geeks, Geeks] Updated LinkedList [Geeks, For, Geeks]>
Opération 3 : Suppression d'éléments
Afin de supprimer un élément d'une LinkedList, nous pouvons utiliser la méthode remove() . Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont:
questions d'entretien en langage Java
- Remove(Object) : Cette méthode est utilisée pour supprimer simplement un objet de la LinkedList. S'il existe plusieurs objets de ce type, la première occurrence de l'objet est supprimée. remove(int index) : puisqu'une LinkedList 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 LinkedList. Après avoir supprimé l'élément et les index des éléments sont mis à jour, l'objet de LinkedList est mis à jour, donnant une nouvelle liste après la suppression du ou des éléments.
Ci-dessous la mise en œuvre de l'opération ci-dessus :
Java
// Java program to remove elements> // in a LinkedList> > import> java.util.*;> > public> class> GFG {> > >public> static> void> main(String args[])> >{> >LinkedList ll =>new> LinkedList();> > >ll.add(>'Geeks'>);> >ll.add(>'Geeks'>);> >ll.add(>1>,>'For'>);> > >System.out.println(>'Initial LinkedList '> + ll);> > >// Function call> >ll.remove(>1>);> > >System.out.println(>'After the Index Removal '> + ll);> > >ll.remove(>'Geeks'>);> > >System.out.println(>'After the Object Removal '> >+ ll);> >}> }> |
>
>Sortir
Initial LinkedList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>
Opération 4 : Itérer la LinkedList
Il existe plusieurs façons de parcourir LinkedList. Les méthodes les plus connues consistent à utiliser la boucle for de base en combinaison avec une méthode get() pour obtenir l'élément à un index spécifique et la boucle for avancée.
Ci-dessous la mise en œuvre de l'opération ci-dessus :
Java
// Java program to iterate the elements> // in an LinkedList> > import> java.util.*;> > public> class> GFG {> > >public> static> void> main(String args[])> >{> >LinkedList ll> >=>new> LinkedList();> > >ll.add(>'Geeks'>);> >ll.add(>'Geeks'>);> >ll.add(>1>,>'For'>);> > >// Using the Get method and the> >// for loop> >for> (>int> i =>0>; i System.out.print(ll.get(i) + ' '); } System.out.println(); // Using the for each loop for (String str : ll) System.out.print(str + ' '); } }> |
>
>Sortir
Geeks For Geeks Geeks For Geeks>
Opération 4 : liste liée à To Array en utilisant toArray();
Java
import> java.util.*;> public> class> GFG2 {> >public> static> void> main(String[] args)> >{> >LinkedList list=>new> LinkedList();> >list.add(>123>);> >list.add(>12>);> >list.add(>11>);> >list.add(>1134>);> >System.out.println(>'LinkedList: '>+ list);> >Object[] a = list.toArray();> >System.out.print(>'After converted LinkedList to Array: '>);> >for>(Object element : a)> >System.out.print(element+>' '>);> >}> }> |
>
>Sortir
LinkedList: [123, 12, 11, 1134] After converted LinkedList to Array: 123 12 11 1134>
Opération 5-size();
Java
import> java.io.*;> import> java.util.LinkedList;> public> class> GFG2 {> >public> static> void> main(String args[]) {> >LinkedList list =>new> LinkedList();> >list.add(>'Geeks for Geeks '>);> >list.add(>'is best '>);> >// Displaying the size of the list> >System.out.println(>'The size of the linked list is: '> + list.size());> >}> }> |
>
>Sortir
The size of the linked list is: 2>
Opération 7 – removeFirst();
Java
import> java.io.*;> import> java.util.LinkedList;> public> class> GFG2 {> >public> static> void> main(String args[]) {> > >LinkedList list =>new> LinkedList();> >list.add(>10>);> >list.add(>20>);> >list.add(>30>);> >System.out.println(>'LinkedList:'> + list);> >System.out.println(>'The remove first element is: '> + list.removeFirst());> >// Displaying the final list> >System.out.println(>'Final LinkedList:'> + list);> >}> }> |
>
>Sortir
LinkedList:[10, 20, 30] The remove first element is: 10 Final LinkedList:[20, 30]>
Opération 8- Removelast();
Java
import> java.io.*;> import> java.util.LinkedList;> public> class> GFG2 {> >public> static> void> main(String args[])> >{> > >LinkedList list =>new> LinkedList();> >list.add(>10>);> >list.add(>20>);> >list.add(>30>);> >System.out.println(>'LinkedList:'> + list);> >// Remove the tail using removeLast()> >System.out.println(>'The last element is removed: '> + list.removeLast());> >// Displaying the final list> >System.out.println(>'Final LinkedList:'> + list);> >// Remove the tail using removeLast()> >System.out.println(>'The last element is removed: '> + list.removeLast());> >// Displaying the final list> >System.out.println(>'Final LinkedList:'> + list);> >}> }> |
>
>Sortir
LinkedList:[10, 20, 30] The last element is removed: 30 Final LinkedList:[10, 20] The last element is removed: 20 Final LinkedList:[10]>
La classe LinkedList en Java fait partie du Java Collections Framework et fournit une implémentation de liste chaînée de l'interface List. Il permet le stockage et la récupération d'éléments dans une structure de données de liste à double lien, où chaque élément est lié à ses éléments prédécesseur et successeur.
Voici un exemple simple qui montre comment utiliser une LinkedList en Java :
Java
import> java.util.LinkedList;> > public> class> LinkedListExample {> >public> static> void> main(String[] args) {> >// Create a new linked list> >LinkedList linkedList =>new> LinkedList();> > >// Add elements to the linked list> >linkedList.add(>1>);> >linkedList.add(>2>);> >linkedList.add(>3>);> > >// Add an element to the beginning of the linked list> >linkedList.addFirst(>0>);> > >// Add an element to the end of the linked list> >linkedList.addLast(>4>);> > >// Print the elements of the linked list> >for> (>int> i : linkedList) {> >System.out.println(i);> >}> >}> }> |
>
>
faire et while boucle en javaSortir
0 1 2 3 4>
Avantages de l'utilisation de LinkedList en Java :
- Taille dynamique : comme avec Vector, la taille d'une LinkedList peut augmenter ou diminuer de manière dynamique, vous n'avez donc pas à vous soucier de définir une taille initiale.
- Insertions et suppressions efficaces : LinkedList est une structure de données efficace pour insérer ou supprimer des éléments au milieu de la liste car il vous suffit de modifier les liens entre les éléments, plutôt que de déplacer tous les éléments après le point d'insertion ou de suppression.
- Itération flexible : avec une liste chaînée, vous pouvez parcourir efficacement la liste dans les deux sens, puisque chaque élément a une référence à la fois à ses éléments prédécesseur et successeur.
Inconvénients de l’utilisation de LinkedList en Java :
- Performances : LinkedList a des performances plus lentes que ArrayList lorsqu'il s'agit d'accéder à des éléments individuels. En effet, vous devez parcourir la liste pour atteindre l'élément souhaité, alors qu'avec ArrayList, vous pouvez simplement accéder à l'élément souhaité à l'aide d'un index.
- Surcharge de mémoire : LinkedList nécessite plus de mémoire que ArrayList car chaque élément nécessite de la mémoire supplémentaire pour les liens vers ses éléments prédécesseur et successeur.
Livre de référence:
Un bon ouvrage de référence pour en savoir plus sur Java Collections Framework et LinkedList est Java Collections de Naftalin et Wadler. Ce livre fournit un aperçu complet du framework de collections Java, y compris LinkedList, et comprend de nombreux exemples et exercices pour vous aider à comprendre comment utiliser efficacement ces classes.