深入理解Java中的队列（Queue）_java 队列

目录

一、什么是队列（Queue）？

二、队列中的常用方法

三、Java中的队列接口和实现类

1. LinkedList

2. ArrayDeque

3. PriorityQueue

四、队列的应用场景

1.消息队列

2.线程池任务调度

3.缓存淘汰策略

4.网络请求调度

5.广度优先搜索（BFS）

五、关于队列的题目

1.模拟排队

2.任务调度

3.循环队列

4.烫手山芋

5.队列重排

---

引言：

        在Java编程中，队列（Queue）是一种非常重要的数据结构，它具有先进先出（FIFO）的特性，常用于处理各种异步任务、事件驱动和线程间通信等场景。本文将深入介绍Java中队列的知识，并结合具体的示例进行详细说明。

一、什么是队列（Queue）？

        队列是一种线性数据结构，它的特点是先进先出。在队列中，元素的添加（入队）操作在队尾进行，而元素的移除（出队）操作则在队头进行。因此，队列可以被简单地描述为一个“先进先出”的容器。在Java中，队列接口继承自Collection接口，并提供了丰富的方法来操作队列中的元素。

二、队列中的常用方法

1. add(E e) 和 offer(E e)：添加元素到队列

   Queue<String> queue = new LinkedList<>();
   queue.add("A");
   queue.offer("B");
   // 队列中的元素：[A, B]
   

2. remove() 和 poll()：移除并返回队列头部的元素

   Queue<String> queue = new LinkedList<>();
   queue.add("A");
   queue.add("B");
   String headElement = queue.remove();
   // headElement 的值为 "A"，队列中的元素：[B]
   

3. element() 和 peek()：获取队列头部的元素，但不移除

   Queue<String> queue = new LinkedList<>();
   queue.add("A");
   queue.add("B");
   String headElement = queue.element();
   // headElement 的值为 "A"，队列中的元素：[A, B]
   

4. isEmpty()：检查队列是否为空

   Queue<String> queue = new LinkedList<>();
   boolean isEmpty = queue.isEmpty();
   // isEmpty 的值为 true
   

5. size()：返回队列中元素的个数

   Queue<String> queue = new LinkedList<>();
   queue.add("A");
   queue.add("B");
   int size = queue.size();
   // size 的值为 2
   

6. clear()：清空队列中的所有元素

   Queue<String> queue = new LinkedList<>();
   queue.add("A");
   queue.add("B");
   queue.clear();
   // 队列中的元素为空
   

三、Java中的队列接口和实现类

        Java提供了多种队列的实现类，其中最常用的包括LinkedList、ArrayDeque和PriorityQueue等。这些实现类都实现了Queue接口，并在不同的场景中拥有各自的优势。下面分别介绍这几种队列实现类的特点及使用方法。

1. LinkedList

        LinkedList是Java中常用的双向链表实现，它同时实现了List接口和Queue接口，因此可以被用作队列来进行元素的添加和移除操作。以下是一个简单的示例：

Queue<String> queue = new LinkedList<>();
queue.offer("a"); // 入队
queue.offer("b");
String element = queue.poll(); // 出队
System.out.println(element); // 输出：a

        在上面的示例中，我们使用LinkedList实现了一个队列，并通过offer()方法进行入队操作，通过poll()方法进行出队操作。

2. ArrayDeque

        ArrayDeque是一种基于数组的双端队列实现，它同样实现了Queue接口，并且在尾部添加和移除元素的操作具有较低的时间复杂度。以下是ArrayDeque的简单示例：

Queue<Integer> queue = new ArrayDeque<>();
queue.offer(1); // 入队
queue.offer(2);
int element = queue.poll(); // 出队
System.out.println(element); // 输出：1

        在这个示例中，我们使用ArrayDeque实现了一个整数队列，并进行了入队和出队的操作。

3. PriorityQueue

        PriorityQueue是一个基于优先级堆的无界优先级队列实现，它可以确保每次出队的元素都是队列中优先级最高的元素。以下是PriorityQueue的简单示例：

Queue<Integer> queue = new PriorityQueue<>();
queue.offer(5); // 入队
queue.offer(3);
int element = queue.poll(); // 出队
System.out.println(element); // 输出：3

        在上述示例中，我们使用PriorityQueue实现了一个整数队列，并通过offer()方法入队，通过poll()方法出队。需要注意的是，PriorityQueue会根据元素的自然顺序或者比较器来决定出队顺序。

四、队列的应用场景

1.消息队列

用于实现系统间的异步通信，可以将消息发送到队列中，然后由消费者从队列中取出进行处理。

示例：使用RabbitMQ、Kafka等消息队列实现订单处理系统，将订单消息发送到队列中，后台系统从队列中消费并处理订单。

2.线程池任务调度

用于按照顺序执行任务，通常使用队列来存储待执行的任务。

示例：使用Java的Executor框架创建线程池，将需要执行的任务添加到线程池的任务队列中，线程池按照队列中的顺序依次执行任务。

3.缓存淘汰策略

用于限制缓存的大小，当缓存满时，通过队列中的先进先出规则来淘汰最早添加的元素。

示例：使用LRU（最近最少使用）缓存淘汰算法，将不经常访问的数据移出缓存，保留最近访问的数据在缓存中。

4.网络请求调度

用于处理请求队列，按照先到先处理的顺序处理请求，实现请求的有序处理。

示例：Web服务器接收到多个客户端请求时，将请求放入请求队列，然后按照队列中的顺序依次处理请求。

5.广度优先搜索（BFS）

用于解决图和树等数据结构的搜索问题，通过队列来实现搜索的层级遍历。

示例：在无权图中找到两个节点之间的最短路径，使用广度优先搜索算法，使用队列来实现节点的层级遍历。

这些只是队列应用的一小部分示例，队列作为一种重要的数据结构，在计算机科学中被广泛应用。具体的应用场景根据问题的需求和实际情况选择合适的方法和数据结构。

五、关于队列的题目

1.模拟排队

        编写一个程序，使用队列模拟排队的情景。用户可以加入队列，处理队列中的人，并显示当前队列的状态。

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
 
public class QueueSimulation {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        Scanner scanner = new Scanner(System.in);
 
        while (true) {
            System.out.println("请选择操作：1.加入队列 2.处理队列 3.显示队列状态 4.退出");
            int choice = scanner.nextInt();
            switch (choice) {
                case 1:
                    System.out.println("请输入加入队列的人名：");
                    String name = scanner.next();
                    queue.add(name);
                    System.out.println(name + " 加入了队列。");
                    break;
                case 2:
                    String processed = queue.poll();
                    if (processed != null) {
                        System.out.println(processed + " 被处理了。");
                    } else {
                        System.out.println("队列为空，无人可处理。");
                    }
                    break;
                case 3:
                    System.out.println("当前队列状态：" + queue);
                    break;
                case 4:
                    System.out.println("程序结束。");
                    return;
                default:
                    System.out.println("输入无效，请重新输入。");
                    break;
            }
        }
    }
}

        这个程序通过创建一个字符串类型的队列来模拟人员排队的情景。用户可以选择加入队列、处理队列中的人或者显示当前队列状态。运行程序后，按照提示输入数字选择操作即可体验队列的基本操作。 

2.任务调度

        设计一个任务调度器，要求按照优先级从高到低执行任务。每个任务都有一个优先级值，值越高优先级越高。

import java.util.PriorityQueue;
 
class Task implements Comparable<Task> {
    private String name;
    private int priority;
 
    public Task(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }
 
    public String getName() {
        return name;
    }
 
    public int getPriority() {
        return priority;
    }
 
    @Override
    public int compareTo(Task other) {
        return other.getPriority() - this.getPriority();
    }
}
 
public class TaskScheduler {
    public static void main(String[] args) {
        PriorityQueue<Task> queue = new PriorityQueue<>();
        queue.add(new Task("Task 1", 5));
        queue.add(new Task("Task 2", 3));
        queue.add(new Task("Task 3", 1));
 
        while (!queue.isEmpty()) {
            Task task = queue.poll();
            String name = task.getName();
            System.out.println("Executing task: " + name);
        }
    }
}

        在这个示例中，我们定义了一个 Task 类来表示任务，包含任务的名称和优先级。我们实现了 Comparable 接口，根据任务的优先级进行比较。

        在 TaskScheduler 类的 main 方法中，我们使用一个优先级队列 PriorityQueue 来存储任务。我们添加了三个带有不同优先级的任务到队列中。然后，我们从队列中不断取出任务并打印任务名称，直到队列为空。

        在这个示例中，任务的执行顺序将按照优先级从高到低进行。你可以根据需要修改任务的名称和优先级，并向队列中添加更多任务来进行测试。

3.循环队列

        实现一个循环队列，它有固定的容量，当队列已满时，新增的元素将替换队列头部的元素

public class CircularQueue {
    private int[] queue;
    private int front;
    private int rear;
    private int capacity;
    private int size;
 
    public CircularQueue(int capacity) {
        this.capacity = capacity;
        this.queue = new int[capacity];
        this.front = 0;
        this.rear = 0;
        this.size = 0;
    }
 
    public void enqueue(int item) {
        if (isFull()) {
            System.out.println("队列已满，执行替换操作: " + item);
            queue[rear] = item;
            rear = (rear + 1) % capacity;
            front = (front + 1) % capacity;
        } else {
            System.out.println("入队元素: " + item);
            queue[rear] = item;
            rear = (rear + 1) % capacity;
            size++;
        }
    }
 
    public int dequeue() {
        if (isEmpty()) {
            System.out.println("队列为空，无法出队。");
            return -1;
        } else {
            int item = queue[front];
            front = (front + 1) % capacity;
            size--;
            System.out.println("出队元素: " + item);
            return item;
        }
    }
 
    public boolean isEmpty() {
        return size == 0;
    }
 
    public boolean isFull() {
        return size == capacity;
    }
 
    public static void main(String[] args) {
        CircularQueue circularQueue = new CircularQueue(5);
        circularQueue.enqueue(1);
        circularQueue.enqueue(2);
        circularQueue.enqueue(3);
        circularQueue.enqueue(4);
        circularQueue.enqueue(5);
        circularQueue.enqueue(6); // 替换元素
        circularQueue.dequeue();
        circularQueue.dequeue();
        circularQueue.dequeue();
        circularQueue.dequeue();
        circularQueue.dequeue();
        circularQueue.dequeue(); // 队列为空
    }
}

        在这个示例中，我们创建了一个名为 CircularQueue 的类来表示循环队列，用一个固定大小的整型数组来存储队列元素。队列中的元素由 front 和 rear 指针来表示，front 指向队列头部，rear 指向队列尾部的下一个位置。

        在 enqueue 方法中，当队列已满时，我们执行替换操作。在 dequeue 方法中，我们从队列头部出队元素。同时，我们也提供了判断队列是否为空和队列是否已满的方法。

        在 main 方法中，我们展示了循环队列的基本使用方式：执行入队和出队操作，并观察替换元素和队列为空的情况。

4.烫手山芋

        在一个游戏中，玩家围成一个圈，手持一个山芋向左传递，每传递一定次数后，持芋者被淘汰。使用队列来模拟这个过程。

要使用队列来模拟烫手山芋游戏的过程，可以按照以下步骤进行操作：

1. 创建一个队列来存储玩家的编号。
2. 将所有玩家的编号依次加入队列中。
3. 定义一个传递次数（如5次）来确定需要传递多少次后，持芋者被淘汰。
4. 循环进行传递操作：将队首的玩家编号取出并加入队尾，重复指定的传递次数。
5. 每次传递完成后，队首的玩家被淘汰，并从队列中移除。
6. 重复进行步骤 4 和 5，直到队列中只剩下最后一个玩家为止。
7. 最后剩下的玩家为胜利者。

import java.util.LinkedList;
import java.util.Queue;
 
public class HotPotatoGame {
    public static void main(String[] args) {
        int passCount = 5; // 传递次数
        String[] players = {"Alice", "Bob", "Charlie", "David", "Emma", "Frank"}; // 玩家姓名数组
 
        Queue<String> queue = new LinkedList<>();
        for (String player : players) {
            queue.add(player); // 将玩家加入队列
        }
 
        while (queue.size() > 1) {
            for (int i = 0; i < passCount - 1; i++) {
                String currentPlayer = queue.poll();
                queue.add(currentPlayer); // 将玩家传递指定次数后加回队列尾部
            }
            String eliminatedPlayer = queue.poll();
            System.out.println("玩家 " + eliminatedPlayer + " 被淘汰.");
        }
 
        String winner = queue.poll();
        System.out.println("胜利者是 " + winner + "!");
    }
}

        在这个示例中，我们使用了一个队列来模拟烫手山芋游戏。我们定义了传递次数 passCount 为 5，玩家数组 players 包含了参与游戏的所有玩家。

        在 main 方法中，我们首先创建了一个队列，并将所有玩家按顺序添加到队列中。

        然后，我们使用循环来模拟传递过程。每次循环前，我们将队首的玩家取出并加入队尾，重复执行传递次数减 1 次。当传递次数达到指定的次数后，当前队首的玩家被淘汰，并从队列中移除。

        最终，当队列中只剩下最后一个玩家时，他被宣布为胜利者。

5.队列重排

        给定一个队列，要求将队列中的元素按照特定规则重新排列。例如，将所有偶数放在队列前面，奇数放在队列后面。

        要将给定队列中的元素按照特定规则重新排列，可以使用一个辅助队列来实现。以下是一个示例实现，将偶数元素放在队列前面，奇数元素放在队列后面：

import java.util.LinkedList;
import java.util.Queue;
 
public class QueueReorder {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.add(4);
        queue.add(5);
 
        Queue<Integer> reorderedQueue = reorderQueue(queue);
 
        System.out.println("重新排列后的队列：");
        while (!reorderedQueue.isEmpty()) {
            System.out.print(reorderedQueue.poll() + " ");
        }
    }
 
    public static Queue<Integer> reorderQueue(Queue<Integer> queue) {
        Queue<Integer> reorderedQueue = new LinkedList<>();
        Queue<Integer> oddQueue = new LinkedList<>(); // 奇数队列
        Queue<Integer> evenQueue = new LinkedList<>(); // 偶数队列
 
        // 将元素按照奇偶分别加入两个辅助队列
        while (!queue.isEmpty()) {
            int num = queue.poll();
            if (num % 2 == 0) {
                evenQueue.add(num);
            } else {
                oddQueue.add(num);
            }
        }
 
        // 将偶数队列的元素加入重新排列后的队列
        while (!evenQueue.isEmpty()) {
            reorderedQueue.add(evenQueue.poll());
        }
 
        // 将奇数队列的元素加入重新排列后的队列
        while (!oddQueue.isEmpty()) {
            reorderedQueue.add(oddQueue.poll());
        }
 
        return reorderedQueue;
    }
}

        在这个示例中，我们首先创建了一个原始队列 queue，并向队列中添加了一些整数。

        然后，我们定义了三个辅助队列：reorderedQueue 用于存储重新排列后的队列，oddQueue 用于存储奇数元素，evenQueue 用于存储偶数元素。

        接下来，我们遍历原始队列，将元素按照奇偶分别加入到对应的辅助队列。

        最后，我们将偶数队列的元素依次加入 reorderedQueue，然后将奇数队列的元素依次加入 reorderedQueue。

        最终，返回 reorderedQueue，即为重新排列后的队列。

总结：

        通过本文的介绍，我们深入了解了Java中队列的知识，并介绍了三种常用的队列实现类：LinkedList、ArrayDeque和PriorityQueue。队列作为一种重要的数据结构，在Java编程中具有广泛的应用场景，对于处理异步任务、事件驱动和多线程等问题有着重要的作用。希望本文对你加深对Java队列的理解有所帮助。