What is the difference between a LinkedList and a Deque in terms of usage and performance?

In Java Collections, LinkedList and Deque are both implementations of the Queue interface. However, there are some differences in terms of usage and performance.

LinkedList is a doubly-linked list implementation of the List and Queue interfaces. It allows for fast insertion and deletion at the beginning and end of the list, but slower access times for elements in the middle. It is not thread-safe, so it is not recommended to use in multi-threaded environments.

On the other hand, Deque (short for "double-ended queue") is an interface that extends the Queue interface and provides additional methods to allow for insertion and deletion at both ends of the queue. It can be implemented by classes such as ArrayDeque or LinkedList. The ArrayDeque implementation provides better performance for most operations compared to LinkedList, especially when used as a queue. It is also thread-safe, making it a good choice for multi-threaded environments.

Here’s an example code snippet that demonstrates the differences in usage between LinkedList and ArrayDeque:

import java.util.LinkedList;
import java.util.ArrayDeque;

public class QueueDemo {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        ArrayDeque<String> arrayDeque = new ArrayDeque<>();

        // Adding elements to LinkedList and ArrayDeque
        linkedList.add("Apple");
        arrayDeque.add("Apple");

        linkedList.add("Banana");
        arrayDeque.add("Banana");

        linkedList.add("Cherry");
        arrayDeque.add("Cherry");

        // Removing elements from LinkedList and ArrayDeque
        linkedList.remove();
        arrayDeque.remove();

        // Iterating over LinkedList and ArrayDeque
        System.out.println("LinkedList:");
        for (String s : linkedList) {
            System.out.println(s);
        }

        System.out.println("ArrayDeque:");
        for (String s : arrayDeque) {
            System.out.println(s);
        }
    }
}

In this example, we create a LinkedList and an ArrayDeque and add three elements to each. We then remove the first element from each, and finally iterate over both to print their contents.

The output of this program would be:

LinkedList:
Banana
Cherry
ArrayDeque:
Banana
Cherry

As we can see, both LinkedList and ArrayDeque have the same elements in the same order after removing the first element. However, ArrayDeque provides better performance for most operations compared to LinkedList, especially when used as a queue. It is also thread-safe, making it a good choice for multi-threaded environments.