对前面的数组模拟队列的优化，充分利用数组。因此将数组看做是一个环形的。（通过取模的方式来实现）

    分析说明：

    1. 尾索引的下一个为头索引时表示队列满，即将队列容量空出一个作为约定，这个在做判断队列满的时候需要注意

      1.         （rear + 1）% maxSize == front 满<br /> rear == front 空

    2. 分析示意图：

      image.png

    代码实现：

    1. package com.atguigu.sparseArray;
    3. import java.util.Scanner;
    5. /**
    6.  * 模拟环形队列
    7.  * @author Dxkstart
    8.  * @create 2021-09-30-8:43
    9.  */
    10. public class CirceArrayQueue {
    11.     public static void main(String[] args) {
    12.         Scanner scanner = new Scanner(System.in);
    13.         //测试数组模拟环形队列
    14.         //创建一个队列
    15.         CirceArray circeArray = new CirceArray(5);//这里设置5，但是队列最大有效数据个数为4
    16.         boolean b = true;
    17.         while (b) {
    18.             System.out.println("请选择功能：");
    19.             System.out.println("1.显示队列");
    20.             System.out.println("2.添加数据到队列");
    21.             System.out.println("3.从队列取出数据");
    22.             System.out.println("4.查看队列头的数据");
    23.             System.out.println("5.退出程序");
    24.             int key = scanner.nextInt();//用户输入数字选择功能
    26.             switch (key) {
    27.                 case (1):
    28.                     circeArray.showQueue();
    29.                     System.out.println();
    30.                     break;
    31.                 case (2):
    32.                     System.out.println("请输入一个数字");
    33.                     int value = scanner.nextInt();//用户输入队列的数据
    34.                     circeArray.addQueue(value);
    35.                     System.out.println();
    36.                     break;
    37.                 case (3):
    38.                     try {
    39.                         System.out.println("取出的数据是：" + circeArray.getQueue());
    40.                     } catch (Exception e) {
    41.                         System.out.println(e.getMessage());
    42.                     }
    43.                     System.out.println();
    44.                     break;
    45.                 case (4):
    46.                     try {
    47.                         System.out.println("队列头数据为：" + circeArray.headQueue());
    48.                     } catch (Exception e) {
    49.                         System.out.println(e.getMessage());
    50.                     }
    51.                     System.out.println();
    52.                     break;
    53.                 case (5):
    54.                     b = false;
    55.                     break;
    57.                 default:
    58.                     break;
    60.             }
    61.         }
    62.         System.out.println("程序退出！");
    65.     }
    66. }
    68. class CirceArray{
    69.     private int maxSize;//表示数组的最大容量
    70.     /*
    71.     front 变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素
    72.     front的初始值 = 0
    73.      */
    74.     private int front;
    75.     /*
    76.     rear 变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置。因为希望空出一个空间作为约定
    77.     rear的初始值 = 0
    78.      */
    79.     private int rear;//队列尾
    80.     private int[] arr;//该数组用于存放数据，模拟队列
    82.     public CirceArray(int arrMaxSize){
    83.         maxSize = arrMaxSize;
    84.         arr = new int[maxSize];
    86.     }
    88.     //判断队列是否已满
    89.     public boolean isFull() {
    90.         return (rear + 1) % maxSize == front;
    91.     }
    93.     //判断队列是否为空
    94.     public boolean isEmpty() {
    95.         return rear == front;
    96.     }
    98.     //添加数据到队列
    99.     public void addQueue(int n) {
    100.         //先判断队列是否已满
    101.         if (isFull()) {
    102.             System.out.println("队列已满，不能再添加啦！");
    103.             return;
    104.         }
    105.         //直接将数据加入
    106.         arr[rear] = n;
    107.         //将rear后移一位，这里必须考虑取模，因为是环形队列
    108.         rear = (rear + 1) % maxSize;
    109.         System.out.println("添加成功！");
    110.     }
    112.     //获取出队列的数据，出队列，先进先出
    113.     public int getQueue() {
    114.         //先判断队列是否为空
    115.         if (isEmpty()) {
    116.             //通过抛出异常来处理
    117.             throw new RuntimeException("队列为空呢！");
    118.         }
    119.         //这里需要分析出front是指向队列的第一个元素
    120.         //1.先把front对应的值保存在一个临时变量中
    121.         //2.将front后移
    122.         //3.返回临时变量的值
    123.         int value = arr[front];
    124.         front = (front + 1) % maxSize;
    125.         return value;
    126.     }
    128.     //显示队列的所有数据
    129.     public void showQueue() {
    130.         //遍历
    131.         if (isEmpty()) {
    132.             System.out.println("队列为空，不能遍历");
    133.             return;
    134.         }
    135.         //思路：从front开始遍历，遍历多少个元素
    136.         //动脑筋
    137.         for (int i = front; i <front + size(); i++) {//遍历多少次这是重点
    138.             System.out.printf("arr[%d] = %d\n",i % maxSize,arr[i % maxSize]);
    140.         }
    141.     }
    142.     //求出当前队列中有多少个元素
    143.     public int size(){
    144.         return (rear + maxSize - front) % maxSize;
    145.     }
    147.     //显示队列的头数据，注意不是取出数据
    148.     public int headQueue() {
    149.         if (isEmpty()) {
    150.             throw new RuntimeException("队列为空，没有数据");
    151.         }
    152.         return arr[front % maxSize];
    153.     }
    157. }