在 Java 中，队列（Queue）是一种常用的数据结构，用于按顺序存储和检索元素。Java 提供了多种队列实现，包括普通队列、双端队列、有限双端队列和优先级队列等。下面是这些队列的分类、优缺点、代码示例以及用表格进行对比整理。

队列分类

1. 普通队列（Queue）

   • 接口：java.util.Queue
   • 实现类：LinkedList, PriorityQueue

2. 双端队列（Deque）

   • 接口：java.util.Deque
   • 实现类：ArrayDeque, LinkedList

3. 有限双端队列（BlockingDeque）

   • 接口：java.util.concurrent.BlockingDeque
   • 实现类：LinkedBlockingDeque

4. 优先级队列（PriorityQueue）

   • 接口：java.util.PriorityQueue
   • 实现类：PriorityQueue

详细说明与代码示例

1. 普通队列（Queue）

接口：java.util.Queue

实现类：

• LinkedList
• PriorityQueue

优点：

• 简单易用：提供基本的队列操作。
• 性能良好：LinkedList 提供 O(1) 的插入和删除操作。

缺点：

• 有限功能：不支持双端操作。
• PriorityQueue 不保证元素的顺序，而是按优先级排序。

代码示例：

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

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        queue.add("Alice");
        queue.add("Bob");
        queue.add("Charlie");

        System.out.println("Queue: " + queue);
        System.out.println("Head of Queue: " + queue.peek()); // Alice
        System.out.println("Remove from Queue: " + queue.poll()); // Alice
        System.out.println("Queue after poll: " + queue);
    }
}

2. 双端队列（Deque）

接口：java.util.Deque

实现类：

• ArrayDeque
• LinkedList

优点：

• 双端操作：支持在队列的两端进行插入和删除操作。
• 高性能：ArrayDeque 提供 O(1) 的插入和删除操作。

缺点：

• 复杂性：比普通队列更复杂。

代码示例：

import java.util.ArrayDeque;
import java.util.Deque;

public class DequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        deque.addFirst("Alice");
        deque.addLast("Bob");
        deque.addFirst("Charlie");

        System.out.println("Deque: " + deque);
        System.out.println("First Element: " + deque.getFirst()); // Charlie
        System.out.println("Last Element: " + deque.getLast()); // Bob
        System.out.println("Remove First: " + deque.removeFirst()); // Charlie
        System.out.println("Deque after removeFirst: " + deque);
    }
}

3. 有限双端队列（BlockingDeque）

接口：java.util.concurrent.BlockingDeque

实现类：

• LinkedBlockingDeque

优点：

• 线程安全：支持多线程环境下的操作。
• 阻塞操作：提供阻塞的插入和删除操作，适用于生产者-消费者模式。

缺点：

• 性能开销：由于线程安全，性能相对较低。
• 复杂性：比普通队列更复杂。

代码示例：

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.BlockingDeque;

public class BlockingDequeExample {
    public static void main(String[] args) {
        BlockingDeque<String> blockingDeque = new LinkedBlockingDeque<>(3);
        try {
            blockingDeque.putFirst("Alice");
            blockingDeque.putLast("Bob");
            blockingDeque.putFirst("Charlie");

            System.out.println("BlockingDeque: " + blockingDeque);
            System.out.println("Take First: " + blockingDeque.takeFirst()); // Charlie
            System.out.println("BlockingDeque after takeFirst: " + blockingDeque);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

4. 优先级队列（PriorityQueue）

接口：java.util.PriorityQueue

实现类：

• PriorityQueue

优点：

• 优先级排序：元素按优先级排序，优先级高的元素先出队。
• 简单易用：提供基本的队列操作。

缺点：

• 顺序不确定：不保证元素的插入顺序。
• 性能开销：插入和删除操作的时间复杂度为 O(log n)。

代码示例：

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>();
        priorityQueue.add(30);
        priorityQueue.add(20);
        priorityQueue.add(40);
        priorityQueue.add(10);

        System.out.println("PriorityQueue: " + priorityQueue);
        System.out.println("Head of PriorityQueue: " + priorityQueue.peek()); // 10
        System.out.println("Remove from PriorityQueue: " + priorityQueue.poll()); // 10
        System.out.println("PriorityQueue after poll: " + priorityQueue);
    }
}

对比表格

总结

• Queue (LinkedList)：适用于需要基本队列操作的场景，性能良好。
• Queue (PriorityQueue)：适用于需要按优先级排序的场景，简单易用。
• Deque (ArrayDeque)：适用于需要在两端进行操作的场景，高性能。
• Deque (LinkedList)：适用于需要在两端进行操作的场景，高性能。
• BlockingDeque (LinkedBlockingDeque)：适用于需要在多线程环境下进行阻塞操作的场景，线程安全。

通过以上对比，可以根据具体需求选择合适的队列实现方式。