Java LinkedList

La classe LinkedList en Java fait partie du Java Collections Framework et met en œuvre les interfaces List et Deque. Il s'agit d'une liste doublement liée qui fournit une structure de données dynamique pour stocker des éléments. Contrairement aux tableaux, LinkedList permet d'insérer et de supprimer efficacement des éléments aux deux extrémités et au milieu de la liste.

Utilisation

LinkedList est utilisé lorsque des insertions et des suppressions fréquentes sont nécessaires. Elle est particulièrement utile lorsque la taille de la liste n'est pas connue à l'avance ou lorsque des éléments doivent être ajoutés ou supprimés aux deux extrémités de la liste.

Syntax

LinkedList<Type> linkedList = new LinkedList<>();
Propulsé par

• Type: Le type d'éléments stockés dans la liste.
• linkedList: Le nom de l'instance LinkedList.

Exemples

Exemple 1 : Opérations de base

import java.util.LinkedList;

public class LinkedListExample {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        
        // Adding elements
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        
        // Accessing elements
        System.out.println("First element: " + list.getFirst());
        System.out.println("Last element: " + list.getLast());
        
        // Removing elements
        list.removeFirst();
        list.removeLast();
        
        System.out.println("List after removals: " + list);
    }
}
Propulsé par

Cet exemple démontre des opérations de base telles que l'ajout, l'accès et la suppression d'éléments d'un site LinkedList. Nous ajoutons trois fruits à la liste, nous accédons au premier et au dernier élément, puis nous les supprimons.

Exemple 2 : Itérer dans une liste chaînée

import java.util.LinkedList;
import java.util.Iterator;

public class LinkedListIteration {
    public static void main(String[] args) {
        LinkedList<Integer> numbers = new LinkedList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        
        Iterator<Integer> iterator = numbers.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}
Propulsé par

Dans cet exemple, nous utilisons un site Iterator pour parcourir le site LinkedList des entiers. Le site Iterator permet d'accéder à chaque élément de manière séquentielle.

Exemple 3 : Utilisation de LinkedList comme file d'attente

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListAsQueue {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        
        // Enqueue elements
        queue.add("First");
        queue.add("Second");
        queue.add("Third");
        
        // Dequeue elements
        System.out.println("Removed: " + queue.poll());
        System.out.println("Queue after removal: " + queue);
    }
}
Propulsé par

Ici, LinkedList est utilisé comme Queue. Les éléments sont ajoutés à l'aide de add() et supprimés à l'aide de poll(), ce qui démontre un comportement FIFO (First-In-First-Out).

Conseils et bonnes pratiques

• Quand l'utiliser: Utilisez LinkedList lorsque vous devez effectuer des insertions et des suppressions fréquentes, en particulier au début ou à la fin de la liste.
• Considérations relatives aux performances: LinkedList présente un surcoût plus élevé que ArrayList pour l'accès aux éléments par index en raison de sa nature d'accès séquentiel.
• Éléments nuls: LinkedList autorise les éléments null, ce qui permet de gérer les éventuels scénarios NullPointerException.
• Thread Safety: LinkedList n'est pas synchronisé. Utilisez Collections.synchronizedList(new LinkedList<>()) pour des opérations sûres.
• Opérations Deque: Utilisez LinkedList comme Deque pour les opérations de file d'attente à double extrémité, telles que addFirst(), addLast(), removeFirst() et removeLast().