队列

队列是 Java 编程中经常使用的一种数据结构，它遵循先进先出（FIFO）的原则，允许在队尾进行元素的插入，而在队头进行元素的删除。在本文中，我们将深入讨论队列的定义、特性，以及队列在不同场景中的应用。同时，我们将介绍队列的常见操作，提供详细的解释说明和 Java 代码示例。

一、队列的定义

队列是一种有序的元素集合，插入操作（入队）发生在队尾，删除操作（出队）发生在队头。在 Java 中，队列可以通过 Queue 接口及其实现类来表示，例如 LinkedList 和 ArrayDeque。

示例：

Queue<Integer> queue = new LinkedList<>();
queue.offer(1);
queue.offer(2);
queue.offer(3);
queue.offer(4);
queue.offer(5);

二、队列的特性

1. 先进先出（FIFO）

队列遵循先进先出的原则，最先入队的元素将被最先出队。

2. 只能在两端操作

队列的插入操作发生在队尾，删除操作发生在队头。只能在队尾插入，在队头删除。

3. 限制访问范围

在队列中，只能访问和操作队头和队尾元素，不能直接访问其他位置的元素。

三、队列的应用

1. 任务调度

队列常用于任务调度，新任务在队尾入队，调度程序从队头取出任务进行处理。

2. 网络数据传输

网络传输中，队列可用于缓存待发送或接收的数据包，保持数据传输的有序性。

3. 广度优先搜索

在图算法中，队列用于实现广度优先搜索，确保按层级遍历图的节点。

四、队列的常见操作

1. 入队（Offer）

将元素插入队尾。

queue.offer(6);

2. 出队（Poll）

从队头删除并返回元素。

int dequeuedElement = queue.poll();

3. 查看队头元素（Peek）

查看队头元素但不移除。

int frontElement = queue.peek();

五、队列的注意事项

1. 空队列检查

在进行出队操作时，应先检查队列是否为空，以避免空队列异常。

if (!queue.isEmpty()) {
    int dequeuedElement = queue.poll();
}

2. 容量限制

在使用 Queue 接口的实现类时，需要注意其容量限制。如果需要无限容量，可以考虑使用 LinkedList 或 ArrayDeque。

结语

队列作为一种先进先出的数据结构，在 Java 编程中有着广泛的应用。了解队列的定义、特性以及在不同场景中的应用，有助于更好地选择和使用队列，提高程序的效率和可维护性。希望本文能够帮助你更深入地理解和应用 Java 中的队列这一重要的数据结构。

附 ：数组实现队列

public class ArrayQueue {

    public static void main(String[] args) {

        ArrayQueueEntity queue = new ArrayQueueEntity(3);
        //接收用户输入
        char key = ' ';
        Scanner scanner = new Scanner(System.in);
        boolean loop = true;
        //输出一个菜单
        while (loop) {
            System.out.println("s(show): 显示队列");
            System.out.println("e(exit): 退出程序");
            System.out.println("c(clear): 清空队列");
            System.out.println("a(add): 添加数据到队列");
            System.out.println("g(get): 从队列取出数据");
            System.out.println("h(head): 查看队列头的数据");
            System.out.println("t(tail): 查看队列尾的数据");
            //接收一个字符
            key = scanner.next().charAt(0);
            switch (key) {
                //输出队列
                case 's':
                    queue.showQueue();
                    break;
                //添加到队列中
                case 'a':
                    System.out.println("输出一个数");
                    int value = scanner.nextInt();
                    queue.addToQueue(value);
                    break;
                //取出数据
                case 'g':
                    try {
                        int res = queue.getFromQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                //查看队列头的数据
                case 'h':
                    try {
                        int res = queue.headQueue();
                        System.out.printf("队列头的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                //查看队列尾的数据
                case 't':
                    try {
                        int res = queue.tailQueue();
                        System.out.printf("队列尾的数据是%d\n", res);
                    } catch (Exception e) {
                        // TODO: handle exception
                        System.out.println(e.getMessage());
                    }
                    break;
                //清空队列
                case 'c':
                    queue.clearQueue();
                    break;
                //退出
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }

        System.out.println("程序退出~~");
    }


}

//使用数组模拟队列 -- 编写一个ArrayQueue的类

class ArrayQueueEntity {

    /**
     * 数组最大容量
     */
    private int maxSize;

    /**
     * 指向队列的头部
     */
    private int front;

    /**
     * 指向队列的尾部
     */
    private int rear;

    /**
     * 存放数据，模拟队列
     */
    private int[] array;

    /**
     * 队列构造器
     *
     * @param maxSize 最大容量
     */
    public ArrayQueueEntity(int maxSize) {
        this.maxSize = maxSize;
        array = new int[this.maxSize];
        //指向队列头部，分析出front是指向队列头的前一个位置
        front = -1;
        //指向队列尾，指向队列尾的数据（即就是队列的最后一个数据）
        rear = -1;
    }

    /**
     * 判断队列是否满
     */
    public boolean isFull() {
        return rear == this.maxSize - 1;
    }

    /**
     * 判断队列是否为空
     */
    public boolean isEmpty() {
        return front == rear;
    }

    /**
     * 添加数据到队列
     *
     * @param data
     */
    public void addToQueue(int data) {
        //首先判断队列是否满
        if (isFull()) {
            System.out.println("队列已满，不能加入数据");
            return;
        }
        //rear后移一位
        rear++;
        array[rear] = data;
    }

    /**
     * 从队列中取出数据
     *
     * @return data
     */
    public int getFromQueue() {
        //首先判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列为空，不能取出数据");
            throw new RuntimeException("队列为空，不能取出数据");
        }
        //front后移一位
        front++;
        return array[front];
    }

    /**
     * 显示队列所有数据
     */
    public void showQueue() {
        //首先判断队列是否为空
        if (isEmpty()) {
            System.out.println("队列为空，没有数据");
            return;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.printf("array[%d] = %d\n", i, array[i]);
        }
        System.out.println();
    }

    /**
     * 显示队列的头数据，不是取出数据
     *
     * @return data
     */
    public int headQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据");
            throw new RuntimeException("队列为空，没有数据");
        }
        return array[front + 1];
    }

    /**
     * 显示队列的尾数据，不是取出数据
     *
     * @return data
     */
    public int tailQueue() {
        if (isEmpty()) {
            System.out.println("队列为空，没有数据");
            throw new RuntimeException("队列为空，没有数据");
        }
        return array[rear];
    }

    /**
     * 清空队列
     */
    public void clearQueue() {
        front = -1;
        rear = -1;
        array = new int[maxSize];
    }
}