LinkedList (LinkedList) Java

Dans ce tutoriel, nous allons approfondir en détail la classe LinkedList à travers de nombreux exemples.

La classe LinkedList de la frame de collections Java fournit les fonctionnalités de structure de données de liste chaînée.

Interface implémentée par LinkedList

• Java List interface

• Interface Queue de Java

• Java Deque interface

Implémentation de LinkedList dans Java

La classe LinkedList de Java fournit une implémentation de liste chaînée bidirectionnelle.

Chaque élément de la liste chaînée est appelénœuds. Il contient3champs :

• Prev - Stocke l'adresse de l'élément précédent dans la liste. Le premier élément est null.

• Next - Stocke l'adresse du prochain élément dans la liste. Le dernier élément est null.

• Données - Stocke les données réelles.

Les éléments de la liste chaînée ne sont pas stockés en ordre. Au lieu de cela, ils sont dispersés et connectés par des liens (Prev et Next).

Ici, la liste chaînée contient3élément.

• Dog - Le premier élément prend null comme adresse précédente et l'adresse de Cat comme adresse suivante

• Cat - Le deuxième élément prend l'adresse de Dog comme adresse précédente et l'adresse de Cow comme adresse suivante

• Cow - Le dernier élément prend l'adresse de Cat comme adresse précédente et null comme élément suivant

Créer une LinkedList

Voici comment nous créons une liste chaînée en Java :

LinkedList<Type> linkedList = new LinkedList<>();

Ici, Type représente le type de la liste chaînée. Par exemple,

//Créer une liste chaînée de type entier
LinkedList<Integer> linkedList = new LinkedList<>();
//Créer une liste chaînée de type chaîne
LinkedList<String> linkedList = new LinkedList<>();

Créer LinkedList en utilisant une interface

Laissez-nous prendre un exemple.

List<String> animals1　= new LinkedList<>();

Ici, nous utilisons l'interface List pour déclarer une liste chaînée animals1, une liste chaînée ne peut accéder qu'aux méthodes de l'interface List.

Laissez-nous prendre un autre exemple.

Queue<String> animals2　= new LinkedList<>();
Deque<String> animals3　= new LinkedList<>();

Ici, animal2Peut accéder aux méthodes de l'interface Queue.

Cependant, animal3Ne peuvent accéder qu'aux méthodes de l'interface Deque et Queue. Cela parce que Deque est un sous-interface de Queue.

Les méthodes de LinkedList

LinkedList fournit diverses méthodes qui nous permettent d'effectuer différentes opérations sur une liste chaînée.

Ajouter un élément à LinkedList

1.Ajouter un élément :en utilisant la méthode add()

Pour ajouter un élément (nœud) à la fin de la liste chaînée, nous utilisons la méthode add(). Par exemple,

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

Output Result

LinkedList: [Dog, Cat, Horse]

2.Ajouter un élément : en utilisant le numéro d'index

Nous pouvons également utiliser l'index pour ajouter des éléments à la liste chaînée. Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//Ajouter un élément en utilisant l'index
　　　　　　　　animals.add(0,"Dog");
　　　　　　　　animals.add(1,"Cat");
　　　　　　　　animals.add(2,"Horse");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Cat, Horse]

3.Ajouter un élément : ajouter une liste chaînée à une autre liste chaînée

Pour ajouter tous les éléments de la liste chaînée à une autre liste chaînée, nous utilisons la méthode addAll(). Par exemple,

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

Output Result

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

4.Ajouter un élément : en utilisant la méthode listIterator()

Nous pouvons également utiliser la méthode listsIterator() pour ajouter des éléments à la liste chaînée. Pour l'utiliser, nous devons importer le paquet java.util.ListIterator. Par exemple,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//Créer un objet ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.add("Dog");
　　　　　　　　listIterate.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Cat]

Accéder aux éléments LinkedList

1.Accéder aux éléments : en utilisant la méthode get()

Pour accéder aux éléments de la liste chaînée, nous pouvons utiliser la méthode get(). Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Obtenir un élément de la liste chaînée
　　　　　　　　String str = animals.get(1);
　　　　　　　　System.out.print("index1l'élément: \　+　str);
　　　　}
}

Output Result

LinkedList: [Dog, Horse, Cat]
index1l'élément à la position: Horse

2.Accéder aux éléments : en utilisant la méthode iterator()

Pour parcourir les éléments de la liste chaînée, nous pouvons utiliser la méthode iterator(). Nous devons importer le paquet java.util.Iterator pour utiliser cette méthode. Par exemple,

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Créer un objet Iterator
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　System.out.print("LinkedList : ");
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output Result

LinkedList : Dog, Cat, Horse,

Ici,

• hasNext() - Retourner true si l'élément suivant existe

• next() - Retourner l'élément suivant

3.Accès aux éléments : utilisation de la méthode listIterator()

Nous pouvons également utiliser la méthode listIterator() pour itérer sur les éléments de la liste de liens. Pour utiliser cette méthode, nous devons importer le paquet java.util.ListIterator.

La méthode listsIterator() est plus adaptée pour les listes car l'objet listIterator() peut également itérer vers l'arrière. Par exemple,

import java.util.LinkedList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　//Créer un objet ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　System.out.print("LinkedList : ");
　　　　　　　　while(listIterate.hasNext()) {
　　　　　　　　　　　　System.out.print(listIterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　//　Parcourir vers l'arrière
　　　　　　　　System.out.print("\nLinkedList inversée : ");
　　　　　　　　while(listIterate.hasPrevious()) {
　　　　　　　　　　　　System.out.print(listIterate.previous());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output Result

LinkedList : Dog, Horse, Cat,
LinkedList inversée : Cat, Horse, Dog,

Ici,

• hasNext() - Retourner true si l'élément suivant existe

• next() - Retourner l'élément suivant

• hasPrevious() - Retourner true si l'élément précédent existe

• previous() - Retourner l'élément précédent

Recherche d'éléments LinkedList

1.Recherche d'élément : utilisation de la méthode contains()

Pour vérifier si une liste contient un élément spécifique, nous utilisons la méthode contains() par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Vérifier si Dog est dans la liste
　　　　　　　　if(animals.contains("Dog")) {
　　　　　　　　　　　　System.out.println("Dog est dans LinkedList.");
　　　　　　　　}
　　　　}
}

Output Result

LinkedList: [Dog, Horse, Cat]
Dog est dans LinkedList.

2.Recherche d'élément : utilisation de la méthode indexOf()

• indexOf() - Retourner l'index de la première apparition de l'élément

• lastIndexOf() - Retourner l'index de la dernière apparition de l'élément

Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//　在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//La première apparition de Dog
　　　　　　　　int index1　= animals.indexOf("Dog");
　　　　　　　　System.out.println("La première apparition de Dog à l'index: "");　+　index1);
　　　　　　　　//La dernière apparition de Dog
　　　　　　　　int index2　= animals.lastIndexOf("Dog");
　　　　　　　　System.out.println("L'index de la dernière apparition de Dog : ",　+　index2);
　　　　}
}

Output Result

LinkedList : [Dog, Horse, Cat, Dog]
L'index de la première apparition de Dog : 0
L'index de la dernière apparition de Dog :　3

Attention :Si l'élément spécifié n'est pas trouvé, indexOf() et lastIndexOf() retournent tous deux-1.

Modification d'éléments LinkedList

1.Modification d'éléments : utilisation de la méthode set()

Pour modifier des éléments d'une liste liée, nous pouvons utiliser la méthode set(). Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Modification de l'index de valeur3de l'élément
　　　　　　　　animals.set(3, "Zebra");
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList : [Dog, Horse, Cat, Dog]
Nouvelle LinkedList : [Dog, Horse, Cat, Zebra]

2.Modification d'éléments : utilisation de la méthode listIterator()

Nous pouvons également utiliser la méthode listIterator() pour modifier des éléments d'une liste liée. Par exemple,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//　在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Créer un objet ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Modifier l'élément retourné par next()
　　　　　　　　listIterate.set("Cow");
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Cat, Horse]
Nouvelle LinkedList : [Cow, Cat, Horse]

Suppression d'éléments LinkedList

1.Suppression d'éléments : utilisation de la méthode remove()

Pour supprimer des éléments d'une liste liée, nous pouvons utiliser la méthode remove(). Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Zebra");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Suppression de l'index de valeur1de l'élément
　　　　　　　　String str = animals.remove(1);
　　　　　　　　System.out.println("Suppression d'éléments : ",　+　str);
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList : [Dog, Horse, Cat, Zebra]
Suppression d'éléments : Horse
Nouvelle LinkedList : [Dog, Cat, Zebra]

2.Suppression d'éléments : utilisation de la méthode listIterator()

Nous pouvons également utiliser la méthode listsIterator() pour supprimer des éléments d'une liste liée. Par exemple,

import java.util.ArrayList;
import java.util.ListIterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　ArrayList<String> animals = new ArrayList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Créer un objet ListIterator
　　　　　　　　ListIterator<String> listIterate = animals.listIterator();
　　　　　　　　listIterate.next();
　　　　　　　　//Supprimer l'élément retourné par next()
　　　　　　　　listIterate.remove();
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Cat, Horse]
Nouvelle LinkedList: [Cat, Horse]

3. Suppression d'éléments : utilisation de la méthode clear()

Pour supprimer tous les éléments de la liste liée, nous utilisons la méthode clear(). Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Supprimer tous les éléments
　　　　　　　　animals.clear();
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Cat, Horse]
Nouvelle LinkedList: []

Attention :Nous pouvons également utiliser la méthode removeAll() pour supprimer tous les éléments. Cependant, la méthode clear() est plus efficace que la méthode removeAll().

4. Suppression d'éléments : utilisation de la méthode removeIf()

Si un élément satisfait une condition spécifique, nous pouvons également les supprimer de la liste. Pour cela, nous utilisons la méthode removeIf(). Par exemple,

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　LinkedList<Integer> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add(2);
　　　　　　　　animals.add(3);
　　　　　　　　animals.add(4);
　　　　　　　　animals.add(5);
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//　Supprimer tous les éléments inférieurs à4de l'élément
　　　　　　　　animals.removeIf((Integer i)->i <　4);
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　　　　/**　Ici, nous utilisons une expression lambda
　　　　　　　*　　Maintenant, souvenez-vous
　　　　　　　*　　Le paramètre de removeIf() est une condition
　　　　　　　*/
　　　　}
}

Output Result

LinkedList: [2,　3,　4,　5]
Nouvelle LinkedList: [4,　5]

Attention : (Integer i)->i<4 C'est une expression lambda. Pour en savoir plus sur les expressions lambda, veuillez visiterExpression Lambda Java

LinkedList en tant que Deque et Queue

Comme la classe LinkedList implémente également les interfaces Queue et Deque, elle peut également implémenter ces méthodes. Voici quelques méthodes couramment utilisées :

Les méthodes addFirst() et addLast()

• addFirst() - Ajouter l'élément spécifié au début de la liste liée

• addLast() - Ajouter l'élément spécifié à la fin de la liste liée

Par exemple,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//Ajouter un élément au début de la LinkedList
　　　　　　　　animals.addFirst("Cow");
　　　　　　　　animals.addFirst("Dog");
　　　　　　　　animals.addFirst("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//在LinkedList的末尾添加元素
　　　　　　　　animals.addLast("Zebra");
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Cat, Dog, Cow]
Nouvelle LinkedList: [Cat, Dog, Cow, Zebra]

Les méthodes getFirst() et getLast()

• getFirst() - Retourner le premier élément

• getLast() - Retourner le dernier élément

Par exemple,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Obtenir le premier élément de la liste
　　　　　　　　String str1　= animals.getFirst();
　　　　　　　　System.out.println("Premier élément: ")　+　str1);
　　　　　　　　//Obtenir le dernier élément de la liste
　　　　　　　　String str2　= animals.getLast();
　　　　　　　　System.out.println("Dernier élément: ")　+　str2);
　　　　}
}

Output Result

LinkedList: [Dog, Horse, Cat]
Premier élément: Dog
Dernier élément: Cat

Les méthodes removeFirst() et removeLast()

• removeFirst() - Supprimer le premier élément

• removeLast() - Supprimer l'élément final

Par exemple,

import java.util.LinkedList;
import java.util.Deque;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Deque<String> animals = new LinkedList<>();
　　　　　　　　//　在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Supprimer le premier élément de LinkedList
　　　　　　　　String str1　= animals.removeFirst();
　　　　　　　　System.out.println("Élément supprimé: ")　+　str1);
　　　　　　　　//Supprimer l'élément final de LinkedList
　　　　　　　　String str2　= animals.removeLast();
　　　　　　　　System.out.println("Élément supprimé: ")　+　str2);
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Horse, Cat]
Élément supprimé: Dog
Élément supprimé: Cat
Nouvelle LinkedList: [Horse]

La méthode peek()

La méthode peek() retourne le premier élément de la liste (tête). Par exemple,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Accéder au premier élément de LinkedList
　　　　　　　　String str = animals.peek();
　　　　　　　　System.out.println("Accès à l'élément: ")　+　str);
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Horse, Cat]
Accès à l'élément: Dog
新的LinkedList: [Dog, Horse, Cat]

La méthode poll()

La méthode poll() retourne et supprime le premier élément de la liste. Par exemple,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　animals.add("Cat");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//Retourne et supprime le premier élément
　　　　　　　　String str = animals.poll();
　　　　　　　　System.out.println("Élément supprimé: ")　+　str);
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Horse, Cat]
Élément supprimé: Dog
Nouvelle LinkedList: [Horse, Cat]

La méthode offer()

La méthode offer() ajoute l'élément spécifié à la fin de la liste liée. Par exemple,

import java.util.LinkedList;
import java.util.Queue;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Queue<String> animals = new LinkedList<>();
　　　　　　　　//在链表中添加元素
　　　　　　　　animals.add("Dog");
　　　　　　　　animals.add("Horse");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//在LinkedList的末尾添加元素
　　　　　　　　animals.offer("Cat");
　　　　　　　　System.out.println("新的LinkedList: ");　+　animals);
　　　　}
}

Output Result

LinkedList: [Dog, Horse]
新的LinkedList: [Dog, Horse, Cat]

遍历LinkedList迭代

1.使用forEach循环遍历

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建一个链表
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//使用forEach循环
　　　　　　　　System.out.println("访问链表元素:");
　　　　　　　　for(String animal: animals) {
　　　　　　　　　　　　System.out.print(animal);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output Result

LinkedList: [Cow, Cat, Dog]
访问链表元素:
Cow, Cat, Dog,

2.使用for循环

import java.util.LinkedList;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建一个链表
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//使用for循环
　　　　　　　　System.out.println("访问链表元素:");
　　　　　　　　for(int i=0; i < animals.size(); i++) {
　　　　　　　　　　　　System.out.print(animals.get(i));
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output Result

LinkedList: [Cow, Cat, Dog]
访问链表元素:
Cow, Cat, Dog,

在两个示例中，我们都使用循环访问链表的各个元素。

3.使用iterator()方法

我们可以使用iterator()方法访问链表的元素。为了使用这种方法，我们必须导入java.util.Iterator包。

import java.util.LinkedList;
import java.util.Iterator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建一个链表
　　　　　　　　LinkedList<String> animals = new LinkedList<>();
　　　　　　　　animals.add("Cow");
　　　　　　　　animals.add("Cat");
　　　　　　　　animals.add("Dog");
　　　　　　　　System.out.println("LinkedList: "　+　animals);
　　　　　　　　//使用iterator()方法
　　　　　　　　System.out.println("LinkedList使用iterator()方法:");
　　　　　　　　Iterator<String> iterate = animals.iterator();
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output Result

LinkedList: [Cow, Cat, Dog]
LinkedList uses the iterator() method:
Cow, Cat, Dog,

LinkedList vs ArrayList

LinkedList and ArrayList both implement the List interface of the Collections framework. However, there are some differences between them.