手写一个基于数组实现的队列

队列具有先进先出的特点，本文基于数组来实现队列的先进先出的功能

首先看一下效果图

以下是代码具体实现

package com.yenroc.queue;

import java.util.Scanner;

public class ArrayQueueDemo {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("设置队列大小：");
        ArrayQueue<String> queue = new ArrayQueue<>(scanner.nextInt());
        char in = ' ';
        boolean flag = true;
        while (flag){
            System.out.printf("\n\r按s(show)查看队列数据\t按a(add)往队列数据\t按g(get)获取队列数据\t按e(exit)推出程序\n");
            in = scanner.next().charAt(0);
            switch (in){
                case 'a':
                    System.out.print("请输入要加入队列里面的数据：");
                    String next = scanner.next();
                    if (queue.addQueue(next)){
                        System.out.println("添加队列成功");
                    }
                    break;
                case 'g':
                    try {
                        String nextQueue = queue.getQueue();
                        System.out.println("获取队列中的数据="+ nextQueue);
                    } catch (RuntimeException ex){
                        System.out.println(ex.getMessage());
                    }
                    break;
                case 's':
                    queue.showQueueAll();
                    break;
                case 'e':
                    flag = false;
                    break;
                default:
                    System.out.println("输入的参数不在处理范围中");
                    break;
            }
        }
    }
}

/**
 * 利用两个指针font，rear，和一个数组来实现数组循环数组来实现队列的不断添加获取
 * 添加元素： 元素添加到rear指针处，然后real指针后移一位
 * 获取元素： 返回font指针所指元素，然后font指针后移一位
 *  添加时，需要判断队列是否已满。
 *  获取时，需要判断队列是否为空。
 * @param <T>
 */
class ArrayQueue<T>{
    // 队列获取数据的指针
    private int front;
    // 队列插入数据的指针
    private int rear;
    // 队列最大容量
    private int arraySize;
    // 队列数据
    private T[] arr;

    private final int DEFAULT_SIZE = 11;// 实际容量为10

    @SuppressWarnings("unchecked")
    ArrayQueue (int size) {
        if (size < 1) {
            size = DEFAULT_SIZE;
        }
        this.arraySize= ++size;// 因为该算法预留了一个空位置，所以队列大小就要比入参大1
        arr = (T[])new Object[this.arraySize];
        front = 0;
        rear = 0;
    }

    private boolean isEmpty(){
        return front == rear;
    }

    // 判断队列是否满
    private boolean isFull(){
        // 因为是环形，插入数据的指针 领跑 获取数据的指针 一圈则标示满了
        return (rear+1) % arraySize == front;
    }

    public boolean addQueue(T t){
        if (isFull()) {
            System.out.println("队列已经满了，不能添加数据了");
            return false;
        }
        arr[rear] = t;
        rear = (rear+1) % arraySize;// top执行向后一位，如果到头，则从0开始
        return true;
    }

    public T getQueue() throws RuntimeException {
        if (isEmpty()){
            throw new RuntimeException("队列中没有数据,获取数据异常");
        }
        T t = arr[front];
        front = (front+1) % arraySize;
        return t;
    }

    // 显示队列中所有的数据
    public void showQueueAll() {
        if (isEmpty()){
            System.out.println("队列中没有数据");
        }
        // 获取队列的大小， 因为可能插入数据指针 超过 读取数据指针一圈。所以加上最大max取余。
        int queueSize = (rear + arraySize - front) % arraySize;
        for (int i = front; i < front + queueSize; i++) {
            System.out.printf("队列第%d个元素=%s\n", i - front ,arr[i % arraySize]);
        }
    }

}