java中队列如何实现

在Java中，队列可以通过多种方式实现，包括使用内置的Java集合框架类如LinkedList、PriorityQueue，以及阻塞队列类如ArrayBlockingQueue、LinkedBlockingQueue等。 其中，LinkedList 和 PriorityQueue 是最常用的选择。LinkedList 是一个双向链表，它实现了Queue接口，可以用来实现FIFO（先进先出）的队列。PriorityQueue 则是一个基于优先级的队列，元素会根据其自然顺序或指定的比较器排列。

LinkedList 的实现非常直观且常用，它提供了基本的队列操作如插入、删除和遍历。以下详细介绍一下如何使用 LinkedList 来实现队列。

一、使用LinkedList实现队列

LinkedList 是一个双向链表，Java中LinkedList类实现了Queue接口，因此可以直接用于队列的实现。其主要优点是插入和删除操作时间复杂度均为O(1)。

1.1 创建和初始化队列

使用LinkedList实现队列时，我们需要实例化一个LinkedList对象并将其赋值给Queue类型的变量：

import java.util.LinkedList;
import java.util.Queue;
public class LinkedListQueue {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        // Add elements to the queue
        queue.add(1);
        queue.add(2);
        queue.add(3);
        // Display the queue
        System.out.println("Queue: " + queue);
    }
}

1.2 基本操作

插入元素：可以使用add()或offer()方法将元素插入队列。add()方法在队列满时会抛出IllegalStateException，而offer()方法则会返回false。

queue.add(4);   // Inserts the specified element into this queue
queue.offer(5); // Inserts the specified element into this queue

删除元素：可以使用remove()或poll()方法删除并返回队列头部的元素。remove()方法在队列为空时会抛出NoSuchElementException，而poll()方法则会返回null。

int removedElement = queue.remove(); // Retrieves and removes the head of this queue
int polledElement = queue.poll();    // Retrieves and removes the head of this queue

查看队列头部元素：可以使用element()或peek()方法查看队列头部的元素而不删除它。element()方法在队列为空时会抛出NoSuchElementException，而peek()方法则会返回null。

int headElement = queue.element(); // Retrieves, but does not remove, the head of this queue
int peekedElement = queue.peek();  // Retrieves, but does not remove, the head of this queue

检查队列是否为空：可以使用isEmpty()方法来检查队列是否为空。

boolean isEmpty = queue.isEmpty(); // Returns true if this queue contains no elements

二、使用PriorityQueue实现优先级队列

PriorityQueue 是一个基于优先级堆的队列，它可以确保每次取出的元素都是队列中优先级最高的元素。PriorityQueue 默认使用自然顺序（即元素的自然排序）来排序元素，但也可以使用自定义的比较器来定义优先级。

2.1 创建和初始化优先级队列

使用PriorityQueue时，我们需要实例化一个PriorityQueue对象：

import java.util.PriorityQueue;
import java.util.Queue;
public class PriorityQueueDemo {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>();
        // Add elements to the priority queue
        priorityQueue.add(5);
        priorityQueue.add(1);
        priorityQueue.add(3);
        // Display the priority queue
        System.out.println("Priority Queue: " + priorityQueue);
    }
}

2.2 基本操作

插入元素：使用add()或offer()方法插入元素，元素会根据其优先级排列。

priorityQueue.add(4);   // Inserts the specified element into this priority queue
priorityQueue.offer(2); // Inserts the specified element into this priority queue

删除元素：使用remove()或poll()方法删除并返回优先级最高的元素。

int removedElement = priorityQueue.remove(); // Retrieves and removes the head of this queue
int polledElement = priorityQueue.poll();    // Retrieves and removes the head of this queue

查看队列头部元素：使用element()或peek()方法查看优先级最高的元素而不删除它。

int headElement = priorityQueue.element(); // Retrieves, but does not remove, the head of this queue
int peekedElement = priorityQueue.peek();  // Retrieves, but does not remove, the head of this queue

检查队列是否为空：使用isEmpty()方法来检查队列是否为空。

boolean isEmpty = priorityQueue.isEmpty(); // Returns true if this queue contains no elements

三、使用阻塞队列（BlockingQueue）

阻塞队列（BlockingQueue）是一个线程安全的队列，它在插入或删除元素时可以自动阻塞线程，直到队列有空位或有元素可供删除。Java提供了多种阻塞队列实现，如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等。

3.1 ArrayBlockingQueue

ArrayBlockingQueue 是一个有界的阻塞队列，它使用数组来实现队列。我们需要在创建时指定队列的容量。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ArrayBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(5);
        // Add elements to the blocking queue
        blockingQueue.put(1);
        blockingQueue.put(2);
        blockingQueue.put(3);
        // Display the blocking queue
        System.out.println("Blocking Queue: " + blockingQueue);
    }
}

3.2 LinkedBlockingQueue

LinkedBlockingQueue 是一个可选有界的阻塞队列，它使用链表来实现队列，默认容量为Integer.MAX_VALUE。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class LinkedBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();
        // Add elements to the blocking queue
        blockingQueue.put(1);
        blockingQueue.put(2);
        blockingQueue.put(3);
        // Display the blocking queue
        System.out.println("Blocking Queue: " + blockingQueue);
    }
}

3.3 基本操作

插入元素：使用put()方法插入元素，如果队列满则阻塞线程。

blockingQueue.put(4); // Inserts the specified element into this queue, waiting if necessary

删除元素：使用take()方法删除并返回队列头部的元素，如果队列为空则阻塞线程。

int takenElement = blockingQueue.take(); // Retrieves and removes the head of this queue, waiting if necessary

检查队列是否为空：使用isEmpty()方法来检查队列是否为空。

boolean isEmpty = blockingQueue.isEmpty(); // Returns true if this queue contains no elements

四、Deque（双端队列）

Deque（双端队列）是一个线性集合，支持在队列的两端插入和删除元素。Java提供了ArrayDeque和LinkedList两种实现。

4.1 ArrayDeque

ArrayDeque 是一个基于数组的双端队列，具有较高的性能。

import java.util.ArrayDeque;
import java.util.Deque;
public class ArrayDequeDemo {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();
        // Add elements to the deque
        deque.addFirst(1);
        deque.addLast(2);
        deque.addLast(3);
        // Display the deque
        System.out.println("Deque: " + deque);
    }
}

4.2 LinkedList

LinkedList 也实现了Deque接口，可以用作双端队列。

import java.util.LinkedList;
import java.util.Deque;
public class LinkedListDequeDemo {
    public static void main(String[] args) {
        Deque<Integer> deque = new LinkedList<>();
        // Add elements to the deque
        deque.addFirst(1);
        deque.addLast(2);
        deque.addLast(3);
        // Display the deque
        System.out.println("Deque: " + deque);
    }
}

4.3 基本操作

插入元素：使用addFirst()和addLast()方法在两端插入元素。

deque.addFirst(0); // Inserts the specified element at the front of this deque
deque.addLast(4);  // Inserts the specified element at the end of this deque

删除元素：使用removeFirst()和removeLast()方法在两端删除元素。

int removedFirst = deque.removeFirst(); // Retrieves and removes the first element of this deque
int removedLast = deque.removeLast();   // Retrieves and removes the last element of this deque

查看元素：使用getFirst()和getLast()方法在两端查看元素。

int firstElement = deque.getFirst(); // Retrieves, but does not remove, the first element of this deque
int lastElement = deque.getLast();   // Retrieves, but does not remove, the last element of this deque

检查队列是否为空：使用isEmpty()方法来检查队列是否为空。

boolean isEmpty = deque.isEmpty(); // Returns true if this deque contains no elements

五、总结

在Java中，队列的实现有多种选择，主要包括LinkedList、PriorityQueue、ArrayBlockingQueue、LinkedBlockingQueue、ArrayDeque和LinkedList。每种实现都有其独特的特性和适用场景：

LinkedList：适用于一般的FIFO队列，插入和删除操作时间复杂度均为O(1)。
PriorityQueue：适用于需要元素按优先级排列的场景，插入和删除操作时间复杂度均为O(log n)。
ArrayBlockingQueue 和 LinkedBlockingQueue：适用于多线程场景下的阻塞队列，提供线程安全的插入和删除操作。
ArrayDeque 和 LinkedList：适用于需要在队列两端进行插入和删除操作的场景。

选择适合的队列实现可以根据具体的应用需求来决定。希望本文对你理解Java中队列的实现有所帮助。