数组模拟队列（环形队列）

思路分析

1.front变量的含义不再是第一个元素前一个而是为了让队列循环指向第一个元素位置，也就是说arr[front]就是队列的第一个元素，front初始值不再是-1而是0.

2.rear变量含义也不在指向最后一个位置，而是为了空位循环往后移一位，即rear指向最后一个元素的后一位。rear的初始值与front一样也是0.

3.空位循环：这里我们希望空出一个空间作为约定，使得队列满时数组仍有一个空位未填入数据，如下图
空位循环以浪费一个位置为代价，避免了判断队列空还是满的条件相同的问题.

4.队列满的判断条件：(rear+1)%maxSize=front   (空位循环，首尾之间相差一个，此时空出了arr[rear]的位置)，下图供参考

5.队列为空的条件：rear=front

6.队列中的有效数据个数：(rear-front+maxSize)%maxSize
(当rear大于front时，个数为rear-front，当rear小于front时，个数为(rear-front+maxSize)%maxSize，经整合得到上式)

数组模拟队列（环形队列）（代码实现）

package datastructure;

import java.util.Scanner;

public class queue2 {
    public static void main(String[] args) {
        CircleQueue circleQueue =new CircleQueue(4);//设置为4，有效数据长度为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("a(add):添加数据");
            System.out.println("g(get):从队列中取出数据");

            System.out.println("h(head):查看队列头的数据");
            key = scanner.next().charAt(0);//接收一个字符
            switch (key){
                case's':
                    circleQueue.showQueue();
                    break;
                case'e':
                    scanner.close();
                    loop=false;

                case'a':
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    circleQueue.addQueue(value);
                    break;
                case'g':
                    try{
                        int res=circleQueue.getQueue();
                        System.out.printf("取出数据为%d\n",res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case'h':
                    try {
                        int res=circleQueue.headQueue();
                        System.out.printf("队列头的数据是%d\n",res);
                    } catch (Exception e) {
                        System.out.println(e.getMessage());
                    }
                default:
                    break;

            }
        }


    }
}
    class CircleQueue {
        private int maxSize;//队列最大容量，（数组长度）
        private int front;//队列头
        private int rear;//队列尾
        private int[] arr;//存放数据的数组，用来模拟队列

        //创建队列的构造器
        public CircleQueue(int arrMaxSize) {
            maxSize = arrMaxSize;
            arr = new int[maxSize];//数组模拟队列，数组长度为队列的最大容量
            //front与rear初始值为零，不再赋值
        }

        //判断队列是否空
        public boolean isEmpty() {
            return rear == front;//当首尾指针相等时，队列为空
        }

        //判断队列是否满
        public boolean isFull() {
            return (rear+1)%maxSize==front;//当队列尾号达到最大容量时，队列满
        }
        public void addQueue(int n){
            //加入前先判断队列是否满
            if(isFull()){
                System.out.println("队列已满，不能加入数据");
                return;
            }
            //因为rear指向最后一个数据的后一个位置，所以先在rear处添加数据。
            //又因考虑到循环rear并不是简单自加，而是取模循环
            arr[rear]=n;
            rear=(rear+1)%maxSize;
        }
        //获取队列的数据，查看数据，伪取出（数据依旧在数组中，成为无效数据通过覆盖更新）
        public int getQueue(){
            //判断队列是否为空
            if(isEmpty()){
                //因为返回值可能会和数据搞混这里我们选择抛出异常
                throw new RuntimeException("队列为空，无法取出数据");
            }
            //考虑到循环front也需要取模
            int value=arr[front];
            front=(front+1)%maxSize;
            return value;
        }
        //显示队列所有数据（包含伪取数据）
        public void showQueue(){
            //遍历
            if(isEmpty()){
                System.out.println("队列为空，没有数据");
                return;
            }
            //由于队列存在循环，数据不在固定不变，我们遍历队列要从front开始遍历到rear，遍历次数为队列中有效数据个数
            //空位的存在使得队列满后再添加时，总有一个不属于队列数据存在，所以遍历数据要考虑有效数据
            for (int i=front;i<front+size();i++){
                //因为i的值是递增的，所以不能再以i为下标显示数据（可能会数组越界），这里选择取模作为下标
                System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);

            }
        }
        //防止代码臃肿，这里另起一个方法来计算有效数据个数
        private int size() {
            return (rear-front+maxSize)%maxSize;
        }
        //显示队列首位数据
        public int headQueue(){
            if(isEmpty()){
                System.out.println("队列为空，没有数据");
                throw new RuntimeException("队列为空，没有数据");
            }
            return arr[front];//首尾数据下标为front
        }
        
    }

以下是图解说明